OctoView LabsThe future of IT work
Here is the theorem I keep coming back to, after thirty years in this trade and one very strange summer: generation is cheap. The fitness function is everything.
Code generation is approaching free. Not metaphorically free; operationally free. My system produces more working Go in a day than a team I once led produced in a sprint. If your mental model of IT work is "people who produce code," the future looks like a cliff.
But production was never the whole job, and the parts that remain are the parts that were always the hard ones. I think the work migrates to three layers.
Specifying. Saying precisely what should be true: the intents, the constraints, the domain model, the invariants. Most of what we called programming skill was secretly always this. The language you write it in is changing from Go to English, and the punishment for being vague is changing from a compiler error today to a confident wrong system next month.
Verifying. Writing the gates that bite. Here is the insight my summer forced on me: writing a gate takes more expertise than writing the code it judges, because you must know every way the code can be wrong. And a gate must prove it can catch a planted crime, or it is theater. I now believe adversarial reading is the core craft of the next decade, and that the career ladder inverts: juniors will start by attacking generated code, not by writing forms.
Judging. Accountability is a property of persons. It cannot be automated, even in principle. Someone signs, someone answers, someone carries the liability. As the machines take the hands, the human becomes the constitutional layer: signatures, gates, judgment. This is not a consolation prize. It is the layer everything else exists to serve.
If this sounds like the end of the profession, notice that we have run this experiment before. Compilers did not end programming; they moved it up. Operations became reliability engineering, which is the discipline of writing invariants about systems too large to watch. QA became property-based attack engineering. The people who scoffed at compilers wrote assembly until they did not. The dread rhymes; so does the outcome. IT work does not vanish. It becomes writing the constitution the machines live under.
I can report from the inside, because I live there now. In my most productive recorded week, I wrote almost no code by hand. I wrote rules: structural gates, enforcement patterns, expiry dates on disabled machinery, merge doctrine. The machine wrote the code. I wrote the law. The ledger kept the receipts. In one day that system refused three of my own acts and five of its own AI session's, and those refusals were the product working, not failing.
It is not comfortable work. The vocabulary is new and dense. Some days I cannot see my own system clearly and fly on instruments. Anyone who tells you this future feels like magic has not operated in it. It feels like being a flight engineer for a plane that rebuilds itself mid-flight, and the instruments are the job.
Earlier this year I asked a question in public: can your system testify? This is the other half of that question. Someone must write the laws the system testifies against. That someone is the future of this profession: part engineer, part auditor, part lawmaker.
The engineers who thrive will not be the ones who generate fastest. Generation is everyone's for the price of a subscription. They will be the ones who can say what must be true, prove when it is not, and sign their name to the difference.