Automating Myself: What It Actually Costs to Run a Copy of My Own Judgment

I built Saturn to do the parts of my job I know cold — architecture drafts, code review, bug fixes, continuous codebase auditing. Not "software engineering" in the abstract. My version of it, trained on how I specifically decide things, because nobody understands my own judgment better than I do.

This post is the data behind the claim, and the honest limits of it.

What Saturn actually does

Four capabilities, per its own documentation:

PR Reviewer — continuous two-pass review with inline comments on every pull request.
Codebase Auditor — an always-on sweep for security, privacy, correctness, performance, and accessibility issues, filing and tracking findings.
Code Autopilot — opens and iterates on PRs to fix assigned bugs, largely without me in the loop until review.
Builder Autopilot — researches the codebase, weighs feasibility, and streams a full design doc for new features. A PR only gets created once I approve the design, and it never merges its own work.

That last one matters for how I frame this. Saturn drafts. I still approve. That's not a capability gap — the designs have been consistently strong — it's a deliberate trust boundary, because the cost of a wrong architectural call is expensive and slow to detect. I expect that gate to loosen over time, not because the tool gets smarter, but because trust gets earned.

The cost data

Running Saturn continuously (24x7, across GHCP, GHCP CLI, and Claude Code) costs roughly $8K/month at steady-state — the point where it's engaged essentially every day, running the full loop of audit, review, and autopilot.

Annualized, that's roughly $96K/year. That's the baseline I'm using, not a one-off spike, because the workload behind it is the one I intend to keep running.

The comparison people will push back on

A Principal Engineer (L65-equivalent) in a high-cost market like Seattle runs somewhere in the $400K–$600K+/year range in total comp — base, bonus, stock refreshers, benefits, overhead. Against that, $96K/year for continuous review, audit, bug-fixing, and design-drafting looks like a 4-6x cost advantage.

I want to be precise about what that comparison is and isn't claiming, because it's easy to overstate.

What it is: the cost of running an agent trained on my own decision patterns, continuously, against the fully-loaded cost of employing an engineer at my level. For the categories Saturn actually covers — implementation, review, bug fixes, and now increasingly design — this is a real substitution I'm running against my own work, not a hypothetical.

What it isn't: proof that this generalizes to "AI replaces any Principal Engineer" as a blanket claim. A few reasons:

I'm both the builder and the evaluator. I trained Saturn on my own patterns and I'm the one judging whether its output is "superb." That's the right way to close the trust gap for my own work — I am the ground truth for whether it matches my judgment — but it's not independent validation, and I'd be more careful generalizing this to other engineers' workflows without the same tight builder-evaluator loop.
Cost data isn't output-equivalence data. $8K/month tells me what Saturn costs to run. It doesn't, by itself, prove the audit findings are as deep, or the designs as sound, as what I'd produce manually — that's a separate claim I'm validating through ongoing review, not through the spend number itself.
Jevons paradox is a real risk here. Cheap continuous auditing means I run far more audit cycles than I ever would manually. That's not "AI replaced $500K of audit work" — it's "a new category of continuous work now exists because it got cheap." Valuable, but a different claim than pure substitution.
This doesn't hold up against offshored labor costs — a lower-cost engineering market could beat $96K/year on pure labor cost today. Where this argument gets stronger every quarter is inference pricing: LLM costs keep falling, and the gap that offshoring currently wins on is closing from the other direction.

The framing that actually holds

There are two separate things going on, and conflating them is where most "AI spend is exploding" takes go wrong:

AI as employable agent — Saturn, running continuously, substituting for labor I would otherwise have to hire or perform myself. Compare this against the cost of that labor, not against a zero-AI baseline from five years ago. The category didn't exist before; comparing to "before AI" is like comparing cloud spend to on-prem racks nobody would buy today.
AI as productivity multiplier — tools like Copilot and Claude Code that accelerate an engineer who's still doing the job. This isn't cost substitution, it's output amplification for the same headcount.

Both benefit the business, in different ways. Neither is well-served by comparing today's AI spend to some pre-AI number, because the comparison that matters is spend against marginal value created — not spend against a world where the tool didn't exist.

The line I keep coming back to

A former manager once told me a feature never got greenlit because "there's only one Debu" — the bottleneck wasn't budget or headcount, it was that the specific judgment needed to build it only existed in one person, and it wasn't worth the org's time to grow a second one. That's the constraint Saturn is actually testing: not "can AI do a Principal Engineer's job in general," but "can the specific, hard-won patterns of one engineer's judgment be encoded and run at scale, cheaply enough that the old scarcity constraint stops being the reason something doesn't get built."

So far, for my own work, the answer looks like yes — with the gate still on the fourth capability, and the honest caveat that I'm the one holding the measuring stick.

Saturn is open-sourced under MIT license: github.com/microsoft/saturn