I haven't written a single line of code in six months — and I'm shipping more than ever.
This isn't a hot take. It's what actually happened. Over the past year, my role shifted from writing code to directing its creation — and the results have been better than anything I shipped when I was typing every character myself.
Here's how that evolution played out, in three stages.
Stage 1: The Conventional Engineer
For most of my career, the workflow was simple:
- Read a ticket
- Plan the implementation
- Write code
- Run it, break it, fix it, repeat
- Push a PR
The craft was typing. Success meant memorizing syntax, understanding standard libraries deeply, and maintaining complex mental models of entire systems. Productivity was directly correlated with time spent writing code. Contribution graphs were a reasonable proxy for output.
This stage built foundational skills — syntax fluency, library knowledge, the ability to debug systems by reading code, and pattern recognition. I enjoyed it. There's real satisfaction in translating a mental model into actual code, character by character.
But it was slow. I just didn't know it yet.
Stage 2: The AI-Assisted Engineer
It started gradually. Copilot, then Cursor — sophisticated autocomplete that finished my sentences while I was still thinking about what to type. Stack Overflow trips disappeared. Documentation lookups got shorter.
If Stage 1 was cooking alone, Stage 2 was cooking with a sous-chef.
The most valuable part wasn't code generation — it was code navigation. Claude could trace entire code flows, linking files and functions into simplified overviews. What used to take thirty minutes of searching became instant clarity.
As the capabilities deepened, something interesting happened: syntax knowledge started to fade. I stopped memorizing API signatures. But my code-reading skills and pattern recognition became more critical — I could evaluate generated code instantly, recognizing wrong abstractions and inappropriate solutions.
The thing slowing me down had stopped being typing, and started being supervision.
Stage 3: The Orchestrator
This is where things got interesting. Claude Code and agent looping capabilities changed the game entirely. I stopped writing code and started directing its creation.
Looping Execution
Agents run tasks end-to-end automatically. I generate a PRD, submit it to agents, and check back only when they're stuck or finished.
Context Management
Maintaining sharp performance across sessions means tracking what happened in each loop, where the PRD stands, and ensuring both agents and I stay oriented. This is harder than it sounds.
Skills as Infrastructure
Rather than repeating instructions every session, I encoded my working methodology, codebase conventions, and domain rules into reusable skills — essentially creating specialized "engineers" for specific types of tasks.
Multi-Agent Orchestration
Multiple agents handle different projects simultaneously. Years of experience — the "scar tissue" like knowing which database tables require billing approval — got encoded into artifacts that scale across sessions.
The transformation is tangible: features that used to take two full days now take twenty minutes for a PRD, one to two hours of agent execution, and fifteen minutes of final review.
The Limitations
Context drift is real — agents silently lose the thread over long sessions. Debugging opaque failures requires gut instinct and experience. And I'll be honest: my ability to write code unassisted has noticeably softened.
What Carries Forward, What Falls Away
Skills that are declining:
- Raw syntax recall
- API memorization
- Typing speed
- Rote language proficiency
These fade fastest because machines replicate them most completely. They also anchored my early career identity, which makes the loss feel personal.
Skills that are compounding:
Pattern recognition and debugging intuition. Years spent tracing bugs through stack traces and recognizing race conditions now drive every brief and code review. I debug faster by directing agents precisely rather than reading code manually.
Business context and repository knowledge. Understanding how data flows between applications, the edge cases, the legacy workarounds — this is a massive advantage when managing multiple agents. This institutional knowledge now gets encoded into agent skills rather than remaining trapped in my head.
Taste and judgment. The engineers who thrive at the orchestrator stage are the ones who can look at a diff and know, in their gut, it's wrong. Orchestration requires evaluating correctness. A conductor who can't hear a flat note is just gesturing.
The Paradox
The skills that atrophy are the ones machines replicate well — syntax, boilerplate, recall. The skills that compound are the ones machines can't generate on their own — judgment, context, taste, institutional memory.
The irony is that those compounding skills were built by doing the very thing that's now being automated.
The Quiet Revolution: Disposable Code
Beyond production code, there's a shift that doesn't get talked about enough: exploratory and investigative code became economically feasible.
Before, investigating a hunch cost too much — time, focus, context switching. I'd skip the investigation, leave the question unanswered, ship around the uncertainty.
Now: describing a data anomaly produces a working investigative script in under a minute. Testing a hypothesis takes fifteen minutes instead of hours.
Things that are suddenly worth doing:
- Parsing vendor XML feeds to verify invoice integrity
- Analyzing six months of logs to correlate latency spikes with deployments
- Writing migration validators that compare staging and production row counts
- Generating production-shaped mock payloads with realistic variance
This is the spreadsheet moment of the 1980s — not just making accountants faster, but making entire classes of previously unjustifiable analysis workable. The cost of satisfying curiosity collapsed.
For me, this is at least half of the "shipping more than ever" feeling — not faster production code, but a dramatic expansion of what's even worth attempting.
Where This Goes
This evolution wasn't deliberate. It happened through incremental delegation and increasing trust in agents until the job itself changed shape.
Six months in, I'm still adjusting. Some days feel superhuman. Other days — when Claude is down or running slow — I feel the accumulated rust and wonder whether this is evolution or dependency.
What I do know: the future-proof engineers won't be the fastest typists or the most thorough memorizers. They'll be the ones who understand systems deeply enough to direct them — who carry enough context to catch when the agent is wrong, and enough taste to define what "right" looks like for their specific codebase, domain, and team.
A Warning
If you're an engineer ignoring these tools, the gap is widening. An engineer using agents effectively isn't marginally faster — they're operating at a fundamentally different scale. The longer you wait to engage, the harder it gets to catch up.
The baseline for what "productive" means is quietly being reset, and it won't wait for anyone to catch up.
What happens to junior engineers who never build these foundational skills manually? When interviews test syntax recall but actual jobs look like orchestration? That's the next piece.
Originally published on Medium.