Question 1

How do you use AI tools in your day-to-day work?

Accepted Answer

Describe a concrete workflow rather than listing tool names. Structure: 1. Repo setup: "The project has a CLAUDE.md — build commands, architecture rules. Permission rules live in .claude/settings.json and are committed." 2. Task flow: I understand the requirement myself → plan mode for large changes → execute in small steps → compile/test at each step. 3. Review: a review skill before the PR, then I read the diff myself. 4. Feedback loop: any correction I make twice goes into CLAUDE.md or a skill. Then give one concrete example — getting tests onto an untested module, then refactoring it. Close with: "Where I see the most benefit is the work that always slipped: test coverage, documentation, small technical debt. Writing new features was never the bottleneck." That avoids the productivity cliché and shows real experience.

Question 2

Tell me about a time you rejected an AI suggestion.

Accepted Answer

Come to this question with a prepared story — improvising lands weakly. Structure: context → the suggestion → why I rejected it → the outcome. A sample shape: "We had a duplicate class build error. The agent proposed a fix: downgrade the library version in libs.versions.toml. The build went green. I rejected it because: A version change affects the whole project — other modules used that library too. It didn't solve the root cause, it hid it. The conflict was still there. Instead I used dependencyInsight to find where the transitive dependency came from — a third library was pulling the old version. The right fix was a narrow exclude on that. Then I wrote the lesson into CLAUDE.md: 'don't change versions without asking'." This answer shows three things: technical depth, not deferring to the tool, and turning a lesson into a system.

Question 3

What do you not delegate to the agent?

Accepted Answer

Give the criterion before the list — that lifts the answer to senior level. "My criterion is two questions: how expensive is a mistake, and what would catch it?" What I don't delegate: Cryptography and key management — a mistake compiles, passes tests, and the weakness stays. No automatic layer catches it. Payment and financial logic — regulatory requirements, very high cost of error. Collection/sharing of user data — privacy and legal liability. Release configuration (R8, signing) — mistakes only surface for users. Understanding the requirement itself — the agent doesn't know it, and can implement the wrong requirement perfectly. Then draw the boundary properly (this matters): "Even in these areas the agent helps — it analyses, presents options, finds the documentation. The difference is that a human makes and verifies the final change. The agent advises, it doesn't author."

Question 4

How do you ensure the quality of agent-written code?

Accepted Answer

Order the layers cheapest to most expensive — then make the distinguishing point. 1. Compile — non-existent APIs, type errors. 2. Lint — deprecated usage. 3. Tests — wrong logic. I make tests part of the task so the agent checks itself. 4. Agent review — via a skill, before the PR. 5. Human review — business logic and architecture. The distinguishing point: "None of these layers is AI-specific — they exist anyway. What changes is that with more code volume manual checking doesn't scale; automating the layers stops being optional." A second point: "The agent saying 'done' is a claim; command output is evidence. I always name the verification command in the task and look at the output." Those two points separate this from an ordinary "I write tests" answer.

Question 5

What do you do when the agent's context window fills up?

Accepted Answer

First show you recognise the symptom: the agent forgets a decision you agreed earlier, asks repeated questions, quality drifts down. Immediate fix: a new session plus a narrow task. Simple, and the most effective. Systemic fixes: Decisions that must survive between sessions belong in CLAUDE.md, not in chat. Split large tasks — each part in its own session. Use subagents: context-hungry work like searching happens in a separate context and only the result comes back. Narrow the task so the agent reads fewer files. A nuance that shows depth: "Context filling happens gradually and quality degrades gradually — there's no hard error. So I split long sessions deliberately: new task, new session. That prevents the problem rather than reacting to it."

Question 6

How would you guide junior developers working with AI?

Accepted Answer

Name the real risk first — it is the centre of this question: "The risk is that a junior merges code they don't understand and no learning happens. The code works, the PR passes, but the developer doesn't grow. Long-term that costs the team more than the speed the agent gave." Rules: 1. Don't merge code you don't understand. The most important one. 2. Move in small steps — one task, one verification, one commit. 3. Think first, then ask. Form your own approach at least in outline, then compare with the agent's. That protects the learning. Teach techniques: ask for an explanation, ask for simplification, ask for alternatives, have tests written. In review: I ask "what does this function do?". No answer, the PR goes back. Model it: in my own PRs I explain where I rejected the agent's suggestion. The junior sees that rejecting is normal. What I would not do: ban it. They'll use it anyway — just hidden and unguided.

Weak answer	Strong answer
"I use Copilot and Claude, they help a lot."	"The repo has a CLAUDE.md and a review skill; my daily workflow is…"
"AI can write anything."	"I don't delegate crypto or payment logic, because a mistake compiles and passes tests."
"I don't trust AI."	"Trust isn't the question — the question is where the verification layers sit."
"I've become twice as fast."	"We finally got tests onto untested modules — that work always used to slip."

Questions about your AI workflow

📚 Sources and documentation