Context, Not Code

After 30 years of coding, I stopped writing code manually — and there’s no going back. This post isn’t about how I’m doing it, but what I’m learning from trying to automate myself out of a job.

Here’s the short version:

1. Context is everything — structured inputs unlock reliable outputs.
2. Let AI write prompts for itself — it’s better at this than you think.
3. Build feedback into the process — AI gets better when it remembers.
4. Define “done” clearly — good tests mean fewer corrections.

Let’s unpack this.

Two months ago, I asked myself a simple question: what if I let AI do all the coding? Not assist — do it. I’d been experimenting with Cursor and Claude Code, and the results were promising. So I made a challenge: one week, no manual coding. Just prompts.

Week one was clunky but doable, worth another week trying. Week two? Better. Week three? I stopped looking back. Since then, I’ve written exactly zero production code by hand. Sure, I still do tiny edits — delete a stray comment, fix a typo — but that’s about 1% of the job.

I even started using MacWhisper to dictate tasks, skipping the keyboard entirely. It’s not just about productivity — it’s a mental shift. Coding by hand now feels like sewing by hand after discovering a machine. Still craftsmanship, just faster and more focused.

Imagine hiring a brilliant engineer and throwing a task at them with no onboarding, no manual, no playbook. That’s what we do every time we open a new conversation with the AI and ask it to complete a task.

At the beginning of every new chat, the AI just forgot everything.

So I started building context files for every task:

- The original request
- Relevant PRs as examples (AI loves examples)
- A list of relevant files and why they matter
- An implementation plan
- A step-by-step TODO list

That TODO list became the glue — the one thing keeping everything coherent across sessions. It lets me pause, restart, or parallelize work.

I tell the AI: stop after each item. Let me verify. Then go. Without that? It snowballs errors fast. With it? AI becomes a reliable, tireless dev.

That’s the core of this entire experiment: everything hinges on context. The more deliberate and structured it is, the more capable the AI becomes. Every other lesson in this post builds on that — layering, evolving, and automating context to extend what the AI can do.

My first context file was handcrafted. Took time. Felt… wrong. I stopped and asked myself — why am I writing this when the AI can? The AI can write this file.

So I prompted it to do that. Then asked it to improve the prompt. And recently, I’m trying to spawn agent swarms that write context files to build agent swarms.

AI is a better prompt engineer than I am. It pulls patterns, finds edge cases, and rewrites faster than I ever could. What I’m really doing here is giving AI context to create context. It’s meta — and incredibly useful. It loops right back to the core idea: context is the name of the game.

Here’s where it starts to feel uncanny — not because it’s magic, but because it actually works.

At the end of each task, I ask the AI to reflect: what tripped you up? What slowed us down? What should we change next time?

It writes those reflections to the context file. Next task, the lessons are in the prompt. Fewer mistakes. Faster output. And when a batch of tasks is done, I ask it to distill reusable strategies into a persistent CLAUDE.md file.

No magic here. Just structured feedback loops. But the effect is real: the AI gets “better” — not because it learns like a human, but because I made it remember. And what it’s remembering — and improving on — is the context. Every reflection, every note, every tweak is just me iteratively making the context better. In other words, self-improvement is really context evolution.

You want AI to work on its own? Give it a solid test suite.

I use strict TDD: one test, one implementation. I tell the AI:

Implement it using the TDD red-green cycle (one test, one implementation, one test, one implementation), run all tests when the implementation is done to check for regressions.

Without that phrasing, it does weird stuff — writes all tests first, skips steps, breaks working code. But with that exact wording? It usually nails it first try. It costs more tokens, but saves me review time. And again — context is the name of the game. Verification is context: it’s how we tell the AI what’s correct, what’s enough, and where the finish line is. It reminds me of the definition of “done” in agile — if we don’t clearly define what “done” means and provide the necessary context for the AI to check it, it has no way of knowing if it did too little, too much, or just enough.

Verification isn’t just for code. Sometimes I ask the AI to judge its own work. Sometimes I call a second agent with a skeptical prompt to review. Either way, you need checks — or the AI will drift.

A good example

This very post is a good example. Before writing it, I asked the AI to analyze all my previous blog posts and generate a comprehensive style guide tailored to how I write. That guide became the context for generating this post. Then, when I was happy with the draft, I had the AI check it against the style guide for consistency — effectively using the same context as both the foundation and the verification step.

Just as a note: while I use Claude Code for all my coding work, this blog post was written using ChatGPT with Canvas. The style guide, the structure, and this final check — all AI-assisted.

Sometimes people associate this with “vibe coding” — where the focus is on the end result, not necessarily the code that gets you there.

But in my case, the means matter just as much as the end. I still review everything. I ask for improvements. I push for simpler logic, better comments, and cleaner design. I care about the code because it ships. My name’s still on the PR.

So while I do lean heavily on AI, it’s still a tool — a powerful one — but the accountability doesn’t go away. I’ll live with that code — and so will the next person reading it.

Right now, I’m steering a lot. Prompting. Reviewing. Fixing edge cases. I can comfortably manage two simultaneous tasks using AI, but it still demands a lot of context switching — and a fair amount of steering. The dream? A swarm of agents working in parallel, each with enough context to do their job with minimal oversight.

And I’m already thinking more tactically than I used to. Before, a big part of my brain was occupied with operational thinking — remembering function names, parameter orders, implementation quirks. Now I think about how to complete a task, what tests to write, and what the overall plan looks like.

Where I’m heading next is even higher-level: strategic thinking. Organizing tasks, setting goals, designing workflows — not just completing them. I’m not there yet. But I’m testing, I’m trying, and I’m learning.

Built with curiosity, ChatGPT, Claude Code, MacWhisper, and a lot of trial and error.