Audit-grade software, at agent speed.
AI can write a lot of code fast. The hard part is being sure it's right, and being able to show your work a year later when someone asks. I build with agents the way I spent two decades building in regulated shops: the standards and controls are written down as rules, the work gets checked against them as it goes, and every decision leaves a trail.
When the software has to be right
Some projects can ship on instinct. Plenty can't. Anything with money attached, anything compliance touches, anything an auditor will eventually read line by line — for that work, "it runs" was never the bar. You have to pin down what "correct" actually means before you start, and you need evidence the result meets it. That's the work I'm built for.
The approach fits the job
There's no single right way to do this. A small, low-risk change doesn't need much: an agent does the work, I review it, the tests back it up. Something where a mistake is expensive, or has to satisfy a regulator, earns more — agents working in coordination, checkpoints the work has to clear before it moves on, a person in the loop where judgment matters, and a record you can walk back through afterward. The process scales with the stakes, and not past them.
What "smooth" means
A well-constructed lifecycle has a lot of moving parts. Most of them don't need a person — they need to be done correctly, the same way, every time. So I let the system carry that weight. Quality lives in the rules: the checks run continuously, and work only escalates to me when there's a real decision to make or something the system can't resolve on its own.
That leaves people for the parts that actually need them: shaping the idea, getting the requirements right, refining the method, and judging whether the outcome is any good. Taking the human out of the constructed middle is the whole point. That's the smooth part.
Most of the risk is in the requirements
Most teams know what they think they want. What they can't see are the holes in it — the contradictions and missing cases that don't surface until release is close and it's expensive to admit the requirements were wrong. Finding those holes early, before a line of code is written, is the part that takes real experience. It's what the design side of my system is for, and it's where I spend my attention.
Quality as code
The idea isn't new. It's how good platform teams already run cloud infrastructure: write the rules down, let the system enforce them. I'm putting the same discipline around building software with AI. Acceptance criteria, security constraints, and review standards become checks the work has to pass, instead of a document nobody opens. I grew up around software quality and verification, and I've spent a career making it routine instead of heroic. What's new is that agents make doing it thoroughly cheap enough to use on a small project, not just a big one.
Where this is
Straight version: SmoothSDLC is new and pre-revenue, and I don't have outside clients yet. The system is real but young — I'm proving it on a build of my own before I run anyone else's work through it. I'm not taking on customers right now.
If you want to see how I think about all of this, the best place to start is the write-up of how the agent teams actually work: how it works.