I Don't Write Code Anymore

Two years ago, I lived in code. I wrote it, read it, debugged it and spent much of my working day trying to understand why something wasn’t doing what I expected.
I don’t work like that anymore.
Today, I spend perhaps one to five per cent of my time looking at code, and on many days I don’t look at any. I don’t read test cases or use a debugger. If something fails, I describe the failure to an AI and have it investigate. That isn’t a temporary experiment or a plan for how I might work in the future. It’s how I work now.
I talk to AI systems about what I want to build. I discuss concepts, requirements, designs and the behaviour I expect from the finished product. I often have four or five AI systems working on different aspects of a problem. One helps with design, another implements it, another reviews it, and others test the results or challenge the assumptions. I use the systems to examine one another’s work.
My own attention goes mostly to the product: what it does, how it feels to use, what has improved and what is still wrong. I don’t normally inspect the implementation. I wouldn’t have time to inspect every change and test case being produced, and doing so would consume much of the time this way of working has freed up.
Some people will call that vibe coding. I don’t use that description for my work. I’m not asking a model for something plausible and accepting whatever comes back. I’m directing a process with requirements, implementation, testing, review, product-level evaluation and the ability to reject failed results. The useful distinction isn’t whether I look at the source code; it’s whether the process has a serious way of finding out if the result is any good. None of those checks guarantees correctness, but neither does reading the code myself.
I didn’t set out to stop coding. I began with AI assistance, delegated larger tasks as the systems improved, and gradually stopped needing to perform the intermediate work. I still build software, probably more than I have at any other point in my career. The strange part is that I do so while rarely carrying out the activity I spent years learning.
Moving Intelligence Into the Process
I used to begin a software project by thinking about how I would implement it. Now I begin by describing what I want to exist.
Initially, AI helped me write code. Then I gave it larger implementation tasks. When reviewing those implementations became the bottleneck, I gave review and testing to other AI systems. My work moved from implementation to checking the implementation, then towards directing a process that does much of the checking as well.
The next step is already apparent. I still decide which models or agents to use for particular tasks, when a second review is needed and whether to change course. Some of that coordination can also be delegated. The role I occupy today is not necessarily the role I’ll occupy next year.
I think of this as moving intelligence into the process itself. Instead of personally supplying every technical skill involved in building a system, I bring together models, tools, instructions, tests and feedback. They do work that once depended directly on my knowledge and attention.
Experience still affects the result. I can often recognise a poor design, a missing requirement or a problem that will make a system awkward to maintain. But that experience no longer has to be translated into code by my own hands. Someone with much less programming experience can also use AI to produce software they couldn’t have built independently. Whether their result is as good as mine is a separate question.
This change doesn’t require an extraordinary breakthrough every month. Improvements in tool use, context handling, error recovery and evaluation can each allow a little more work to be delegated. I notice the cumulative effect when I return to a problem that was difficult a few months earlier and find that it has become manageable.
Talking Things Into Existence
The most enjoyable part is how little distance there can be between an idea and a first useful result.
Sometimes I have a clear picture of a feature. Sometimes I have only a question. I discuss it with an AI, ask it to explore alternatives, choose a direction and have it build something. I then use the result and explain what isn’t right. The idea itself may change in the conversation. I can investigate several approaches without first committing weeks to writing them.
I do something similar when developing books. I can ask one AI to investigate a subject, another to challenge the research, and another to examine the structure or weaknesses in the argument. I don’t have to read every intermediate draft before the next stage begins. The research still has to stand up to scrutiny, and a polished account can still be wrong, but the amount I can explore has changed.
It would be tempting to call this creating at the speed of thought. The phrase captures the feeling better than the literal speed. Implementation still takes time; sometimes it fails, and sometimes the idea was poor to begin with. What’s different is that I can start testing an idea while I’m still working out what I think about it.
A recent problem in my Writer system illustrates both the attraction and the limitation. I was generating metadata for a 42-chapter book. The process completed chapters one through six and then stopped. I wasn’t looking at the code that ran the job. I was looking at the result: six chapters, when I wanted 42.
I gave the failure back to AI to investigate. The underlying problem was not the content of the book. A background Worker process appeared to be running but could no longer accept work. There was also an environment problem: the executable it needed wasn’t available on the process path. The subsequent changes added recovery for the unhealthy Worker and a way to keep and reconcile valid chapter results rather than losing them because a later chapter failed.
The six completed chapters were recovered. The remaining run wasn’t magically finished; it still depended on correcting the environment. That’s an important part of the story. AI could investigate and repair parts of the workflow, and tests could confirm those repairs, while the original objective of processing all 42 chapters remained incomplete.
That is what working at the level of the product feels like to me. I state the outcome, inspect what actually happened and send the difference back into the process. I don’t need to personally debug the Worker to know that six is not 42.
How Do I Know It Works?
This is the question a programmer should ask after hearing that I rarely read code or tests.
AI systems reviewing other AI systems are not independent evidence of correctness. They can share assumptions, miss the same defect and agree confidently about something that is wrong. I have no reason to think that adding a fourth or fifth model makes those problems disappear.
I look for evidence that is tied to the task rather than to a model’s opinion: executable tests, observed behaviour, comparisons with a known baseline, reproducible results and, where appropriate, an independent review of the actual change. I let AI carry out much of that checking, but I want to know what was checked and what the result establishes.
In a bounded TraceLite experiment, for example, the starting state recorded 21 events and had two failing tests. One AI-generated patch failed deterministic checks and was rejected. There were also unsuccessful attempts that couldn’t be accepted as valid patches, and a retry had to be rerun from the proper baseline. The accepted result recorded three events and passed five tests. A separate review reported no findings on the accepted change.
Those numbers are useful because they refer to something observed. They don’t establish that the tracing system is free of defects, or that the same process will work on every repository. They establish that, in this particular task, a proposed change could be rejected, corrected and checked against a measurable result without me personally stepping through the code.
The Writer example shows the other side. Passing a set of tests for a repair does not mean the complete user objective has been achieved. Recovering six chapters and successfully processing 42 chapters are different outcomes. A process can be technically healthier and still be unfinished.
I can also miss things by evaluating the product from the outside. Security weaknesses, data corruption, failures under load and long-term maintenance problems may not be visible in the experience of using a feature. For systems where mistakes could harm people or cause financial loss, the evidence needed is correspondingly stronger. I don’t regard an attractive interface or an AI review as sufficient assurance.
So I don’t have a general claim that this approach produces better-quality software. I have examples where it allows more checks and faster correction than I could personally perform, alongside failures that remind me why the checks must be meaningful. The quality of the process is something to measure, not assume.
What Happens to Expertise?
There is a difficult question underneath my experience. I can delegate much of the programming because I spent years doing it myself. I developed an understanding of software by writing it, breaking it, fixing it and living with the consequences of earlier decisions. I still use that understanding when deciding what to build or when a result seems wrong.
I am drawing on experience acquired through work I now rarely perform. That makes me an unusual reference point for somebody starting today.
A person with little programming experience can create useful software through AI. If the product is simple and its success is easy to observe, a clear understanding of the user’s needs may matter more than the ability to write elegant code. In other cases, problems lie below the surface: security, data integrity, concurrency, performance or decisions that become expensive years later. Those require ways of evaluating the system that the person may not yet know to ask for.
But I can’t simply conclude that everyone must follow the old route to expertise. Someone learning with AI can investigate failures, run experiments, compare alternatives and acquire judgement in a different way. AI may also improve at evaluating the hidden problems I currently depend on experience to recognise.
I don’t yet know how those forms of expertise compare. I haven’t run an experiment in which experienced and inexperienced people build the same system with similar AI access and their results are independently evaluated. My own productivity is not evidence that an inexperienced person would get the same outcome, or that they wouldn’t.
The question interests me because it is quite personal. Which parts of my experience still make a difference? Which parts can the systems now supply? And can somebody develop the judgement to direct them without spending years working the way I used to?
Those are better questions for me than trying to predict what happens to the whole software labour market from my own desk.
The Boundary
I keep working by looking for the next limit. I describe what I want, let the systems attempt it and examine what comes back. When the result fails, I ask why. Sometimes the problem is the model, sometimes the tools or the evaluation, and sometimes I haven’t understood the problem well enough myself.
My way of interacting with AI won’t suit everyone. Another developer may prefer to inspect every change. A designer may work through images. Somebody building a small personal tool may care only that it behaves as intended. We can use similar models and reach very different results because our aims, experience and standards are different.
That’s why I don’t want to turn my workflow into a set of rules for everybody else, or use it to draw conclusions about employment and the economy that I haven’t researched. I can describe the transformation I’ve experienced and show some of the results. The larger consequences need a different investigation.
I used to think of programming as the thing I did to turn an idea into software. Now I spend most of my time deciding what should exist, working with AI to make it happen, and finding out whether it worked. I still have questions about quality, experience and how much of this can be delegated again.
What changed wasn’t just my productivity. It was my understanding of which parts of the work needed me at all.