Walter
My command center.
Walter is one server that runs my entire practice and sharpens it into something closer to a small engineering department. It's not a product and it's not for sale. It's the reason one person can build to the standard of a much larger team, and it's the honest answer to "how do you do all of this yourself?"
A workshop that remembers everything.
Every project I've built lives in one place: its code, its history, where it runs, what's fragile about it, and every lesson I've learned the hard way keeping it alive. Walter is the machine that holds all of that and puts the right piece of it in front of me at the right moment.
It's a command center on steroids: a central, capable assistant that lets me spend my time on the parts I'm good at instead of the parts a computer should handle. It never forgets a detail of a project I touched eight months ago. It surfaces the exact trap I hit last time before I hit it again. And it lets me operate the whole shop, from architecture to a production fix, from a laptop or a phone.
I still do the engineering. All of it.
This is the part that matters, so I'll be plain about it. Walter makes me faster and sharper. It does not do the thinking for me.
I architect the system before a line is written. I plan the build, write and review the code, write the tests, run the servers, and maintain what ships. Today's best AI models are part of how I move quickly, and I treat them exactly like what they are: powerful instruments that I point, that accelerate every step and replace none of them. This is not a vibe-coding shop. It's a working engineer using the best tools of the moment with his eyes open.
Nothing ships without passing review.
Whatever gets written, whether by me or drafted with a model, runs the same gauntlet before it reaches you. The clever part is that the reviewers come from rival AI labs: different models have different blind spots, and where they disagree is exactly where I look closest. The reviewers only advise. Not one of them can write a line or push a commit. Exactly one person decides what ships.
- The Floor: static analysis on every repo, always on
- The Gatekeeper: automated code review on every change
- The Panel: cross-lab model review, scaled to the risk
- The Inspector: a sandboxed reader with no write access
- Me: architect, reviewer, and the only one who ships
The ideas I'm proud of
A few of the design choices that make Walter more than a folder full of scripts.
Memory that writes itself back
A lesson learned once gets written into the machine's own playbooks the same day, so it reaches every future session automatically. Institutional knowledge that doesn't evaporate when I close the laptop.
Cross-lab review as signal
Models from different companies review each other's work. Their disagreement isn't noise to smooth over; it's a map of exactly where a human's judgment is needed.
It audits its own decay
Scheduled jobs mine each day's work for lessons that never got written down, and each week flag knowledge going stale or projects going quiet. The system looks for its own rot before I have to.
A local brain, always available
A small language model runs on the box itself, so the everyday helper keeps working even if every cloud vendor is unreachable, and it can only ever propose from a fixed menu of safe actions. Its worst failure mode is "unhelpful," never "dangerous."
One writer, no exceptions
By construction, exactly one agent can change code, and every reviewer is read-only. The safety isn't a policy I remember to follow; it's built into how the machine is wired.
This is what it looks like to open the shop.
The whole shop, from a phone.
Walter has a web front door, and it was built mobile-first on purpose. Most of the useful moments are not at a desk: a question arrives at dinner, something needs checking on a train, a fix wants shipping before I get home.
Nearly everything here started as a command I was tired of typing on a phone keyboard. The terminal came first, and the off-the-shelf client for it simply did not render on a small screen, so it got replaced with one that does. Everything after that followed the same rule: if I would not want to do it from a bus, it does not belong in the door.
It sits behind a real front door of its own: a login, long-lived sessions I can revoke from anywhere, and an audit trail. It exposes genuine power, so the security is load-bearing rather than decorative.
The result is that the practice does not have office hours. Picking up a project mid-thought takes about ten seconds, from wherever I am.
- Sessions. Live terminal sessions, exactly as I left them. Resume a piece of work mid-sentence from a different device.
- Project registry. Every project, what it is, where it runs, and what state it's in. Browsable, filterable, editable in place.
- Local sites. The development site fleet, with what's actually running shown as evidence rather than assumed, and start and stop where I need them.
- Files. Browse the box, pull a file down, drop one in. Credentials and key directories are refused outright.
- Notes. Quick capture for the thought that arrives at the wrong moment, in a place a later session can read and turn into a real ticket.
- Health. A light in the corner watching disk, memory, services, and whether the backups are actually fresh. It goes amber before I have to wonder.
You get a small team's discipline from one person.
You don't buy Walter. You benefit from it. When you hand me a problem, it's built inside a system with the memory, the review discipline, and the operational care of a much larger shop, and delivered with the focus and directness of working with one person who actually wrote the code.
That's the whole idea. Use the best tools available, keep a human doing the engineering, and let the machine handle everything that isn't the interesting part.
Bring me something interesting.
A messy integration, a tool that doesn't exist yet, or a codebase that needs a real set of eyes. This is the shop it gets built in.