A platform, steered — not handed off.

The short version first, because it's my stance: The machine did the bulk of the work. But it didn't do it alone. I steered it, reviewed it and reined it in again and again. Take the human out, and you don't build a product — you build chaos in record time.

How it went

I started on 4 December 2025. The first weeks were dense collaboration: I described, the AI built, I corrected. In December and January the foundation took shape at a high cadence — hundreds, then over a thousand commits a month.

February brought a big break: a substantial rebuild that moved more code than any other month. That happens when an early architecture decision turns out to be too tight — and it's one of the moments where it shows whether you still understand the project.

From spring on the work shifted: away from constantly typing along, towards orchestration. I set up automation that plans and implements, and an „Automatic Tester" — a tool of my own that clicks through the UI on its own, finds bugs and reports them. Those reports automatically became fix tasks, which were implemented and verified in turn. In April and May the system ran largely by itself — and I turned from typist into conductor.

That, by the way, is exactly the journey across the three levels I otherwise describe: from manual via semi-automated to orchestrated. I didn't learn it in theory, but on RAMP.

What RAMP is

RAMP is a multi-tenant platform for automating IT operations — teams model recurring runbooks and run them under control. The unsexy-but-hard part: it speaks four identity worlds at once (Native, LDAP, OIDC/Keycloak, Windows), configurable per tenant. Real-time updates and a full end-to-end test suite are part of it. In short: not a demo toy, but enterprise reality.

• .NET backend, React frontend (TypeScript)
• multi-layered, role-based permissions
• SQL/SQLite via a data layer, Redis for real time
• several tenants on one production server, plus a Docker cluster
• backup/restore, database migrations, custom helper tools

The rest — the actual operational logic — I deliberately leave out here. That's the part you book me for.

What the AI actually did

What's remarkable isn't that the AI wrote code. What's remarkable is that it had a hand in the whole chain:

• Deployment — from the build to the repeated, clean re-provisioning of the production server.
• Server configuration — identity providers, directory services, certificates, multi-tenant setup.
• Git — almost 3,900 commits across several working branches, coordinated.
• Builds & tests — backend, frontend, unit and end-to-end tests.
• Scripts — all the automation around it.
• Automatic Tester — the autonomous UI tester that finds bugs.
• More sites — the product page (run-book.de) and the docs (doc.run-book.de) were also built and deployed with Claude.

My role in this: decide what gets built, set guardrails — and review, review, review.

How I steered the machine

An example that says a lot about the collaboration. One day I wanted to re-provision the entire production server (run-book.de) from scratch — including deleting all data. My instruction was terse and destructive. The AI did not do it right away. It replied, in essence:

„Before I touch anything irreversible in production, I want to confirm the scope — I won't touch anything until we agree."

And it laid out a phased plan, with all the questions I hadn't asked. That's how it should be: the machine is fast, but responsibility stays with the human — and good steering means leaving it room for questions before something breaks.

The uncomfortable truth about productivity

Here comes the lesson that taught me the most. In my interactive sessions I measured how long the machine waited on me — and how long I waited on it.

The result: the machine waited about 17 times longer for my answer than I did for its. It computes in minutes. Most of the wall-clock time it spends waiting for a decision from me.

That's the half of the truth missing from the glossy promises: AI doesn't simply make things faster. It shifts the bottleneck — from typing to human availability and review. Whoever measures productivity only by the model's pace is measuring the wrong thing.

How the repo grew

One day is a complete outlier: on 17 February 2026, in a single day, around a million lines were inserted and almost as many deleted — a one-off mass rebuild. (Raw line counts overstate it: in a big restructuring, moved and generated code counts too.) This one day compresses the whole chart. Remove it, and the real pattern emerges:

Over six months, almost 3,900 commits and a six-figure-line codebase came to be — in waves: a dense build-up at the start, the big rebuild in February, then the calmer, automation-carried continuous operation.

Where it snagged

So the picture is complete — the points that hurt:

• The big rebuild. An early decision didn't carry far enough; in February a lot had to be reworked. With AI that's fast — but it's just as much a risk as doing it by hand.
• The overview. After months I sat in front of my own project and in places knew it as little as inherited foreign code. Understanding no longer arises as a by-product of typing — you have to actively reclaim it.
• Hygiene. Without supervision, temp files end up in the project and ballast in the git history. Cleaning up is part of the job.
• The machine's limit. There were bugs the AI couldn't find for a long time — in the end I had to hunt them down myself. That's exactly why you need someone who knows the craft.

What I learned from it

Much of what I tell people today about working with AI, I learned on RAMP: that you have to tell the machine a story instead of a spec sheet. That reviewing isn't optional, it's the foundation. That you have to keep the overview actively. And that the senior becomes the bottleneck and the actual value — not the tool.

Summary

RAMP is my proof that something serious can come out of Claude Code — a production-ready platform, in six months, built largely machine-driven. And it's my proof that this needs an experienced human at the wheel. The speed and the scale are real. The price is steering, review and overview — planned for deliberately, not a surprise.

Steered, not handed off.