The Developer Career Bet - Writing Specs Not Code in the AI Age
The Developer Career Bet - Writing Specs Not Code in the AI Age
Here is a career bet that has turned out to be true: the job of a developer is increasingly about writing specifications, not writing code.
Running 5 Claude Code agents in parallel, the actual daily work becomes writing detailed CLAUDE.md files and reviewing their diffs. The agents write the code. You write the intent.
The Market Data Is Unambiguous
A survey of 500 tech leaders conducted in early 2025 found that 72% plan to reduce entry-level developer hiring while 64% intend to increase investment in AI tools and training. JetBrains' State of Developer Ecosystem 2025 report found that developers using AI coding tools report completing in three days what previously took two weeks - but the nature of the work has shifted toward higher-level problem definition and review.
One developer's account captures the shift precisely: "I now accomplish in three days what previously took two weeks. But the work has shifted - I spend more time defining problems correctly and verifying solutions than writing every line of code myself."
This is not replacement. It is a rebalancing of what developers do with their time.
From Code Writer to Spec Writer
This shift is not theoretical. It is happening now in teams building with AI coding agents. The most productive developers are not the fastest typists or the ones who memorize the most API signatures. They are the ones who can write the clearest, most unambiguous specifications.
A good CLAUDE.md file is essentially a product spec, architecture doc, and style guide combined into a single document that an agent uses as its primary context:
What to build. Feature descriptions specific enough that the agent does not need to guess. Not "add authentication" but "add JWT-based authentication using the existing User model, with refresh token rotation, and a 24-hour access token expiry. Store refresh tokens in the database with the schema defined in /docs/db-schema.md."
How to build it. Architecture constraints, naming conventions, file organization patterns, which libraries to use and which to avoid. Agents will make choices about implementation details unless you specify them. If you have opinions, put them in the document.
What not to do. Explicit anti-patterns and hard boundaries. Agents have patterns they default to - over-engineering abstractions, using the most recent library they know about regardless of whether it fits the project, creating new files when modifying existing ones would be better. Listing the specific anti-patterns you have seen from previous agent runs prevents them from recurring.
What a CLAUDE.md File Looks Like in Practice
Here is a fragment of an effective specification section:
## Database
Use the existing Prisma client from `lib/prisma.ts`. Do not install a different ORM.
All database queries must go through service files in `lib/services/`.
Direct Prisma calls from API routes or React components are not allowed.
When adding a new table:
1. Add the model to `prisma/schema.prisma`
2. Run `npx prisma migrate dev --name <descriptive-name>`
3. Create a corresponding service file in `lib/services/<table-name>.ts`
4. Export all service functions as named exports
Do not use `prisma.user.findMany()` with no `where` clause - all queries must filter
on at least one field to prevent full table scans.
This level of specificity looks excessive until you watch an agent ignore all of it because you left it out. Agents implement what the document says. Behavior that is not specified gets filled in with defaults that may not match your project's conventions.
The New Skill Stack
The skills that matter now are different from the skills that mattered five years ago:
Decomposition. Breaking a feature into agent-sized tasks that can run in parallel without stepping on each other. If two agents modify the same file simultaneously, you get merge conflicts. The decomposition work is deciding which pieces are truly independent.
Specification writing. Being precise enough that five different agents produce consistent, compatible code. This requires understanding the problem space well enough to describe it unambiguously - which is itself a valuable engineering skill.
Diff review. Reading and evaluating code you did not write, at volume, quickly. A single agent session can produce hundreds of lines of changes. Reviewing that output efficiently requires understanding the problem deeply enough to spot when the implementation drifts from the intent.
System thinking. Understanding how the pieces fit together when each piece was written by a different agent. Each agent has no knowledge of what the others are doing. Keeping the overall system coherent is the human role.
The Mistake Most Developers Make
The common failure mode is treating AI coding agents as autocomplete rather than as autonomous implementors. Running one agent at a time, for single-file changes, with constant hand-holding.
This captures some productivity gain but misses the structural shift. The full leverage comes from writing a complete specification, running multiple agents on independent pieces in parallel, reviewing their output, and integrating the results.
That workflow requires trusting the specification enough to let agents work unsupervised for longer periods. Building that trust means writing better specifications. The investment in specification quality is what converts AI coding tools from a marginal productivity boost to a structural change in how much a single developer can build.
What This Means for New Developers
If you are starting your career today, writing code is still valuable - you need to understand code to review it. You cannot evaluate whether an agent's implementation is correct without understanding the domain and the language.
But the leverage point has moved. The developers who thrive will be the ones who can clearly articulate what needs to exist and why, decompose that into parallel workstreams, maintain system coherence across multiple concurrent agents, and review output for correctness and alignment with intent.
Those skills - specification clarity, decomposition, system thinking, fast review - are teachable. They require the same underlying engineering knowledge they always have. They just apply it at a higher level of abstraction.
- Claude MD and Parallel Agents Guide
- Managing Parallel Claude Agents Tracking
- Multi-Agent Parallel Development
Fazm is an open source macOS AI agent. Open source on GitHub.