I Was a 1x Coder at Best. AI Made Me a 0x Coder

I Was a 1x Coder at Best. AI Made Me a 0x Coder. | Decoupled Logic Over four posts I built an argument. Total understanding is a myth. Cheap generation without governance creates invisible debt. AgenticOps is the discipline layer. Containment is the mechanism. All of that was structural. This one is personal. I Taught Myself to Code I don’t have a computer science degree. I don’t have a software engineering degree. I have no formal training in the thing I’ve done for a living for well over two decades. I learned from books. Then from Google. Then from StackOverflow. I learned from copying patterns I saw in codebases I didn’t fully understand. Eventually from building things that broke and figuring out why. The learning never felt complete. It still doesn’t, and now it feels like I have so much more to learn. I have OCD, ADD, depression, and imposter syndrome. The OCD means I fixate on problems until they resolve. The ADD means I struggle to focus long enough to resolve them efficiently. The depression and imposter syndrome make me doubt everything I do. Those forces fight each other constantly. Sometimes that tension produces good work. Sometimes it produces hours lost chasing details that didn’t matter. On top of that I never felt like an engineer. The people I admired seemed to hold so much of the systems we worked on in their heads, reason about concurrency without breaking a sweat, debug memory and network issues by reading traces. They seemed to operate in a different register, a different dimension. I watched conference talks and understood maybe half of what was said. I read papers and got the gist but not the math. I built mental models that were close enough to be useful but never precise enough to feel confident. The 10x developer myth lived in my head. Not because I believed it literally, but because I measured myself against it. If they were 10x, I was 1x. Maybe. On a good day. Yet, I ended up as a top producer or leader on all the teams I worked on, so I had some value, even if my brain doesn’t believe it. I Spent Years Closing a Gap That Didn’t Matter I tried to get faster. Better tooling, better shortcuts, better frameworks. I optimized my workflow to muscle memory. Split terminals, keyboard shortcuts, IDE configurations I’d tuned over years. I got good enough. I shipped systems that handled real traffic, real money, real consequences. Payment services processing billions of dollars per month where a bug meant many people didn’t get paid. Multi-tenant platforms where a data leak meant one company could see another company’s information. But I never shook the feeling that the real engineers were operating at a level I’d never reach. That the gap between us was fundamental, not experiential. So I kept grinding. More books. More side projects. More late nights trying to understand things other people seemed to just know. The gap I was trying to close was implementation speed. How fast can I translate intent into working code? How quickly can I go from “this is what we need” to “this is what exists”? I was optimizing for the wrong variable the entire time. AI Made Me a 0x Coder Then in October to November of 2025 it felt like AI arrived. Not the theoretical AGI kind. The real kind that writes code. I started using AI agents to build systems. Not as a helper. Not as autocomplete. As the implementation layer. Today I write zero lines of code by hand. Zero. AI scaffolds services. AI implements business logic. AI writes tests. AI refactors modules. AI generates migrations. I define what needs to exist, what constraints it must satisfy, what acceptance criteria must be met, and I evaluate that they are met. The agent does the rest. I code 0x. The skill I spent twenty years building, the ability to translate intent into syntax, is fully delegated. The keystrokes I optimized. The frameworks I memorized. The patterns I drilled into muscle memory. All bypassed. It still feels like a loss. A waste. The thing I’d spent my career trying to master was now something a machine does better and faster. A 1x coder didn’t become 10x. I became 0x. 0x Is Not a Deficit Here’s what I didn’t expect. Letting go of implementation didn’t reduce my output. It multiplied it. AI doesn’t just write code faster and better than me. It writes at a scale I could never match. Full service scaffolding in minutes. Test suites covering edge cases I would have missed. Rewrites and refactors across modules that would have taken me days. I was never going to write at 100x. But I can govern at 100x. In the first post I said I scale containment, not understanding. I wrote that before I’d lived it. Now I have. In the second post I argued the hard parts were never typing. In October 2025 I meant it theoretically. Today, I mean it literally. I don’t type production code. The hard parts, the constraint decisions, the system boundaries, the verification criteria, those are the only parts I do. The six layers from the third post. Intent, agent generation, evaluation, promotion, runtime governance, knowledge compression. Those are not a framework I designed in the abstract. They are the operating system I iterate on because I had to. Because governing agent output is the only way 0x works. The four rings from the fourth post. Constrain inputs, constrain environment, validate outputs, gate promotion. Those are not best practices on a slide. They are the walls of the house I am building to live in. Without them, 0x is reckless. With them, 0x is operational. What a Day Looks Like for a 0x Coder Here is the 0x workflow in practice. Define intent. What value does this slice deliver? What state transitions does it manage? What must never break? Define contracts. Input schemas, output schemas, interface definitions, invariant list. Define tests. Contract tests, integration tests, edge case scenarios. The tests exist before the implementation does. Scope the agent. Mount the contracts, tests, and bounded context into the agent’s workspace. Nothing else. Generate. The agent plans, scaffolds, implements, and refactors inside its scope. Evaluate. The evaluation pipeline runs automatically. Contract tests, static analysis, security scanning, schema validation. Review outcomes. I don’t read generated code line by line. I review whether behavior matches intent. Test results, API output diffs, invariant checks. Approve or reject. If the evidence says it works, promote. If not, refine the constraints and loop. That loop is my job. I don’t write code. I write constraints and review evidence. I don’t delegate my responsibility to deliver value. There are skills, besides coding, that I spent twenty years building that still matter, but not the way I expected. I understand systems well enough to define intent for them. I understand failure modes well enough to write meaningful constraints and acceptance criteria. I understand architecture well enough to scope agents tightly. I understand system risks well enough to judge when evidence is sufficient. Understanding code well enough to evaluate it is different from writing it. Both are valid. Evaluation may matter more now. The Skills That Actually Compound I worried about the wrong things for twenty years. I thought typing speed mattered. What compounds is system design. I thought language mastery mattered. What compounds is constraint definition. I thought memorizing APIs mattered. What compounds is evaluating outcomes. I thought writing code from scratch mattered. What compounds is judging output. I thought line-by-line review mattered. What compounds is evidence-based verification. I thought understanding every line of code mattered. What compounds is understanding boundaries. The first list is what I optimized for as a 1x coder. The second is what I actually use as a 0x one. Every one of those skills in the second list was something I was already doing alongside the coding. Designing systems, defining boundaries, testing behavior, evaluating risk. I just didn’t recognize them as the primary skills because the coding felt like the real work. It never was. The Code Was Never the Value This is the part I had to live to believe. I spent twenty years measuring myself by my ability to produce code. When AI took that ability away, it felt like losing the foundation of my career. Will I miss the act of coding? Yes. But more than that, I worried that without it, I had no value to add. But the foundation was never the code. The foundation was the ability to solve problems and deliver value. My value add was being able to understand systems, judge outcomes, define constraints, and make decisions under uncertainty. Writing a for loop was not where the value lived. The code was always an artifact of those decisions. Not the decisions themselves. The payments service worked because I understood the state transitions, not because I typed the implementation. The multi-tenant platform was secure because I understood the isolation requirements, not because I wrote the permission layer by hand. In the first post I said my decisions are what matter. I believe that more now than when I originally wrote it. I’ve spent time producing real systems without writing a single line of code, and the outcomes are the same or better than what I produced when I typed everything myself. Not because I’m better or AI is better. Because the division of labor is optimized. Humans are good at intent, constraints, judgment, and risk assessment. Agents are good at implementation, coverage, consistency, and speed. Combining them beats either one alone. Coding and Building Are the Same Thing Again Grace Hopper spent her career trying to get away from code. Trying to move programming toward natural language. Uncle Bob Martin called our continued use of the word “code” a reflection of our failure to meet her goal. I think we’re close to meeting it now. Not because prompts are natural language. Because the distinction between “writing code” and “building systems” is dissolving. For decades, building software required coding. You couldn’t build without typing in some weird cryptic syntax. The skills overlapped so completely that we treated them as the same thing. They aren’t. Building is intent, constraints, architecture, verification, judgment. Coding is translating those into syntax. When AI handles the translation, building remains. The distinction was always there. We just couldn’t see it because the two were inseparable. Now they’re separated. And it turns out the building side is where the value was all along. I am a system builder and an AI agent operator. Five Posts. One Thesis. I’ve never fully understood the systems I work in. AI made that worse, but containment made it manageable. Most software is CRUD molded into value. Cheap generation without governance creates invisible debt, but constraint discipline prevents it. AgenticOps is the governance model. Six layers. Four rings of containment. A hard line between what agents generate and what systems execute. The human’s role didn’t shrink. It moved. From implementation to intent. From typing to judgment. From code review to evidence review. And this last part is the one I had to live to believe. The code was never the value. The decisions were. A 0x coder governing a 100x agent produces better outcomes than a 1x coder typing everything by hand. I know because I’m the 0x coder. And I believe the systems I’m building now are as good or better than the systems I hand coded. What’s your experience? Let’s talk about it. Previous: [ How Agents Stay in Bounds ] Next: [You Can Build This. Three Artifacts and a Sandbox.] Share this: Share on X (Opens in new window) X Share on Facebook (Opens in new window) Facebook Share on LinkedIn (Opens in new window) LinkedIn Share on Tumblr (Opens in new window) Tumblr Email a link to a friend (Opens in new window) Email Share on Reddit (Opens in new window) Reddit Like Loading... Related Leave a comment Cancel reply Δ Search for: Follow Blog via Email Enter your email address to follow this blog and receive notifications of new posts by email. Email Address: Follow Join 898 other subscribers Recent Posts I Was a 1x Coder at Best. AI Made Me a 0x Coder. How Agents Stay in Bounds What AgenticOps Actually Looks Like Most Software Is Just CRUD. That’s Not the Problem. I’ve Never Fully Understood the Systems I Work In. AI Is Making That Worse. Categories AgenticOps AI Analytics Architecture Books Career Debugging Design Dev Dev Community DevOps Flow Guru Hello React and TypeScript My Projects Pipeline Planning Quality Test Automation Tips TestPipe This and That Throwback Tuesdays Uncategorized Tags .net core AgenticOps agentic ops agents AI ai agent AI Coding application pool Architecture artificial-intelligence asp.net automation engineering books chatgpt cloud code analysis code coverage code quality pipeline CQRS culprit analysis DevOps dtc event sourcing feature flags feature toggles Featurz first principles git GoCD governance iis LLM lsp memorycache microservice minecraft msbuild MSTest multitenant NAnt nuget NUnit opencover page object model planning powershell powershell dsc production support react.js reportgenerator selenium selenium grid semver software-development solid specflow specifications SQL Server stylecop technology test automation testpipe ThoughtWorks Go Togglz typescript versioning virtual machine visual studio vm VSTest webdriver webforms windbg wordpress worker process RSS RSS - Posts RSS - Comments March 2026 M T W T F S S 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 Comment Reblog Subscribe Subscribed Decoupled Logic Join 42 other subscribers Sign me up Already have a WordPress.com account? Log in now. Privacy Decoupled Logic Subscribe Subscribed Sign up Log in Copy shortlink Report this content View post in Reader Manage subscriptions Collapse this bar %d