
Developers in the age of AI agents: what do we become?
Two years ago the question was "does AI write good code?". Today the question has changed: coding agents read a repository, edit several files, run the tests and open a pull request. On many tasks, typing the code is no longer the step that takes the most time.
So what do we, developers, become? My take after many months of working this way every day, and leading a team that does too: the job is not disappearing, it is moving up a level.
What actually changes
Code is becoming cheap to produce. What stays expensive is knowing which code to produce, and knowing whether it is correct. Working time therefore shifts from writing to everything around it: understanding the need, breaking it down, deciding, verifying.
The four hats of the augmented developer
1. The one who specifies
An agent executes a clear intent very well, and a vague one very poorly. Writing a good ticket, with context, constraints and verifiable acceptance criteria, becomes a technical skill in its own right. The spec is no longer a document for the project manager: it is the program's input.
2. The one who designs
An agent will happily pick the most likely solution, not the one best suited to your system. Module boundaries, the data model, the caching strategy, what should be synchronous or not: these decisions stay human, and mistakes there cost more than ever, because the code implementing them multiplies faster.
3. The one who orchestrates and reviews
We move from author to editor: running several tasks in parallel, reviewing diffs, rejecting, redirecting, merging. Review becomes the central activity. A 400-line PR generated in two minutes still needs a real read, and that is where quality is decided (see my guardrails for coding with an AI assistant).
4. The one accountable for the result
When an incident hits production, "the AI wrote it" is not an answer. Tests, observability, security, performance: the developer stays responsible for what gets merged, whether they typed it or not.
What gains value… and what becomes a commodity
- Becoming a commodity: boilerplate, standard CRUD, turning a clear spec into code, looking up syntax, mechanical migrations.
- Gaining value: domain and user knowledge, systems thinking, the ability to say no, security, critical code reading, communication with product and design.
- Becoming essential: writing tests that actually prove something, and tooling the CI so it catches what a tired human would miss.
The tech lead: framing humans and agents
For a tech lead the job expands: the repository now has to be readable by agents as much as by newcomers.
- A versioned instructions file: conventions, commands, architecture, things not to do. It is the agent's onboarding.
- A strict CI: types, lint, tests, security scanning. The guardrail that never gets tired.
- Small, readable PRs: the rule matters twice as much when code is generated.
- Clear rules: which tools are approved, which data must never leave, who approves what.
# AGENTS.md (excerpt)
- Stack: Next.js App Router, strict TypeScript, Prisma
- Before finishing: pnpm lint && pnpm test
- Never edit migrations that have already been applied
- Every new API route validates its input with zod
- When unsure about an architecture choice: propose, do not decideWhat about juniors?
This is the genuinely hard question. The simple tasks that used to be the learning ground are exactly the ones AI absorbs first. The risk: developers who can get code generated, but cannot understand or debug it.
My position: AI can speed up learning if you use it to understand, not to skip the step. Have it explain unfamiliar code, ask why one approach is better, write it yourself first and then compare. And on the team side, keep giving juniors real responsibilities, with pair programming and teaching-oriented code reviews.
How to prepare, concretely
- Strengthen the fundamentals: HTTP, databases, concurrency, security. You cannot review what you do not understand.
- Practise writing: specs, acceptance criteria, ADRs. Writing clearly is now programming.
- Practise reviewing: read code, a lot, and be able to explain why you reject it.
- Get closer to product: understand why you build, not only how.
- Try the tools, keep a critical mind: they change every month, judgment stays.
Conclusion
We write less code by hand, but we carry more responsibility. The developer becomes specifier, architect, editor and quality owner all at once. This is not the end of the job: it is the end of one part of it, the most mechanical one. What remains, understanding a problem and building the right solution, has always been the heart of the work.