Creator of Claude Code: "Coding is solved"

If you're in a position where you have to trust the code it generates, I dare say you're using it wrong. Let's take a step back and talk about JIT compilers for a second. A JIT compiler is a non-deterministic probabilistic machine that changes the program beneath you as it runs, but within verification gates, so there's a guarantee that your program is verifiably correct and functional, *not* a guarantee of the specific machine code that you're going to be executing. What matters is the highest-level representation (the source code) and that every transformative layer beneath is it verifiably correct. Do you see where I'm headed with this? If you are trying to vibe code, it's effectively the same thing as asking an engineering team to build you a service, and then not checking back in with them until it's done. That's not the way software is written, so why are we trying to use AI tools that way? I think we need to look at agentic tools the same way we look at a JIT compiler. What they output is probabilistic and non-deterministic, may be potentially incorrect, and needs to be validated - just like early JIT compilers. The way we actually write software starts with information gathering and spec composition, even if informally and only in our heads. Turn that into a step with discrete and verifiable outputs. And actually employ some of the theory of the mind, linguistics, and system design knowledge developers accumulate to the task, defining steps with verifiable outputs along the way that mirror what *you* actually do to go from "I need a caching layer" to a PR. My AI workflow looks like: write a high-level input prompt describing the problem with roughly the same wording as the epic for the project [verify], turn that prompt into a series of specification documents that describe the behavior I care about [verify], expand those documents into a series of specifications that describe an entire program (which means looping in things like lifecycle management and logging that I do not care about) [verify], use those specifications to emit module-level specifications [verify], use the module-level specifications to generate tests [verify], then finally use the tests and specs to generate code. Every output in this path is used as input for the next step. Every output can be verified by a human being if you don't trust the AI to do it. Every output is verified against the input that generated it and the original core specification documents. At every step of the process, I can terminate generation, verify in-flight correctness, and resume. The final product will always match the original input contract. There is a lot of "secret sauce" I'm not interested in blathering about to make a pipeline like this work, it doesn't just happen, you have to instruct it to track state across a number of axes between sessions, you have to instruct it to build you prompt preambles so your sessions are all aligned, you have to do a ton of work to make it happen. It's understandable that this isn't common because of that truth, but the secret is: no one is better at helping you orchestrate an LLM to orchestrate a fleet of agents than the LLM is itself. I've started shipping entire projects that come out of the pipeline with a schizophrenic amount of end-to-end tests, are verifiably correct in all cases, and I've never read a line of their code. A microservice that has a public contract, is verifiably behaviorally correct within its contract, and doesn't leak memory / have performance problems / is otherwise production ready has always been a good thing to aim for because of the ability to burn it down, reimplement, and reverify. I'm taking that promise and making it a hard rule for the AI. Within a year or two, I'll have assembled a large enough set of reusable input specifications that I'll be able to meaningfully provide an OpenAPI document, a service-specific behavioral specification, and press go with production-ready output on the other side. One caveat: each run of this pipeline costs several hundred dollars. A basic "read and replay" SQS listener bills out about $300 because of all the intermediate coherency, consistency, and correctness gates. A giant, complex REST service that publishes to a bunch of queues, reads file uploads, services about a dozen endpoints, etc. that took almost 20 hours to generate billed in at over $1200. But it was correct on the other side and $1200 buys me a day or two from one of my contractors, not the several weeks it would take them to build it.