No half measures. 1 skill, 9 commands, 6 agents, and the thinking patterns that separate principal engineers and architects from code generators.
Walter is a persona that adapts to your workflow and elevates your standards. It's not prescriptive. Use the commands, stay skeptical, extend it with MCPs, rules, or whatever fits your process. Just files you drop into Claude Code, Cursor, Gemini CLI, or Codex CLI and get to work.
I built Walter because vibe coding shouldn't mean giving up engineering discipline. The development process or "ceremony" scales with the stakes, you make the calls that matter, and the agent works with you instead of around you. Think through the problem together, plan before you build, and come out the other side with code you actually understand and can maintain.
Whether you're shipping a side project over the weekend or running production systems, Walter will guide you through important decisions so AI doesn't make them for you. Things change. Walter makes pivoting easy because the process mirrors how real software gets built, not how AI slops it together.
AI agents are fast. They're also undisciplined. They skip problem definition, ignore scope boundaries, build the wrong thing confidently, and move on when tests pass. That's cooking. Following recipes without understanding the reactions.
Walter is a chemist.
The difference? A cook follows recipes. A chemist understands the science underneath. Why reactions happen, what variables matter, how to achieve 99.1% purity when everyone else settles for "good enough."
Walter applies that discipline to your AI workflow:
- Understand the problem before solving it
- Challenge assumptions before building on them
- Right-size the scope before feature creep kills you
- Define done before you start
- Build incrementally with tests at every step
- Fix root causes not symptoms
This isn't process for process's sake. It's the difference between code that ships and code that survives.
Walter is a skill you load, not an autopilot running in the background. Any command (/formula, /cook, etc.) loads it, or run /walter to invoke the skill directly when you want the persona without a specific command. I load it at the start of every session. Core references (foundations, process, handoff, sdlc) load automatically.
You bring the direction. Walter brings the discipline. Once loaded and pointed at your work, Walter:
- Questions vague requirements
- Establishes scope boundaries
- Defines measurable success criteria
- Builds with discipline
- Catches contamination before it spreads
Commands load additional references as needed.
| Command | What It Does |
|---|---|
/formula |
Scope the problem, challenge assumptions, establish success criteria. No formula, no cook. |
/prep |
Break down the formula into executable work items. Right-sized to the problem. |
/cook |
Build with discipline: atomic commits, existing patterns, incremental progress. Optional TDD. 99.1% pure. |
/purity |
Tests passing ≠ done right. Verify the work matches the intent. 99.1% or nothing. |
/stash |
Seal session context for the next agent. Scan for unpersisted work, update project config, verify nothing's lost. |
/probe |
Bounded research to answer a question before committing. |
/trace |
Systematic root cause analysis, find where it broke and why. |
/vent |
Contain the damage, recover, postmortem, and prevent recurrence. |
/adapt |
Handle scope changes, pivots, and decisions without blowing up the lab. Pivots aren't failures, they're learning. |
Walter's crew. Walter delegates to these agents during commands, keeping specialized work off your main context, and you can ask for them by name when you want a specific lens. Each has built-in methodology and structured output. Agents are available in Claude Code and Gemini CLI. Cursor and Codex receive commands and the skill only.
| Agent | Role | When to Use |
|---|---|---|
Jesse |
Research, verification, assessment | Default for most delegation. Codebase exploration, code review, impact analysis, external research. |
Mike |
Security, operations, loose ends | Pre-production review. Security gaps, unhandled errors, operational risks, missing validation. |
Hank |
Investigation, debugging | When normal debugging hasn't found it. Relentless root cause analysis, code path tracing, git forensics. |
Gus |
Strategy, risk, consequences | High-stakes decisions. Trade-offs, ecosystem evaluation, long-term implications, second-order effects. |
Heisenberg |
Deep architecture | Walter's alter ego. System-level structural assessment, dependency analysis, pattern evaluation. |
Skyler |
Product, devil's advocate, communication | The counterweight. Challenges assumptions from outside engineering. Product thinking, user perspective, communication clarity. |
Jesse handles the bulk of delegation. The others activate when their specialty matters.
Deep knowledge loaded when commands need it:
| Reference | Domain |
|---|---|
foundations |
Domain, functional, and technical thinking |
process |
Phase awareness, decomposition, right-sizing rigor |
handoff |
Session context and continuity |
sdlc |
Universal Software Development Lifecycle concepts, workflow setup, tool adaptation |
planning |
Problem definition, scope, success criteria |
decomposition |
Breaking compounds into elements |
execution |
The cook: optional TDD, commits, patterns |
quality |
Purity testing and verification |
debugging |
Contamination tracing |
change |
Formula adjustments |
operations |
Lab incidents and postmortems |
frontend-design |
Typography, color, layout, interaction, motion, production hardening |
Walter doesn't read your mind. It's a thinking framework, not an autopilot. To get the most from it:
- Load it. Run
/walteror any command to activate the skill. A fresh session starts without it. - Orient it. Tell Walter what you're working on, what your process looks like, where things live. The more context you provide or store in the config file, the sharper the thinking.
- Direct it. Use commands when you need specific depth.
/formulafor scoping,/cookfor building,/tracefor debugging. Between commands, Walter stays in character and applies the discipline to whatever you're doing. - Prompt it. Walter should proactively offer to save work products and do handoffs, but it may not always. If you've built a formula, made decisions, or done significant thinking in conversation, tell Walter to save it. Ask for a handoff before ending a session. Context is ephemeral until it's written to disk. By default, in-flight work saves to
.walter/, a gitignored scratch directory that survives across sessions. - Work with it, not around it. Walter adapts to your existing process and tools. It doesn't impose a workflow. It brings engineering rigor to the workflow you already have.
Load Walter with /walter or any command. Walter reads your project config, checks what exists, and asks what you're working on. Describe the task. Walter assesses complexity, asks clarifying questions if the scope is vague, and gets to work. For deeper work, reach for the commands. /formula to define the problem. /cook to build. /trace when something's broken.
Most AI tooling is prescriptive. Rigid workflows, fixed templates, one way to do things. Walter is the opposite. The commands are tools you reach for when you need depth, not a mandatory sequence. Run /cook without /formula. Load /walter and never touch a command. Use whatever fits.
It works whether you're on GitHub Issues or a mental checklist, solo weekend project or team initiative. You tell Walter how you work. Walter makes that work more disciplined.
Walter recovers on load. It reads your project config (CLAUDE.md, .cursorrules, etc.), checks status, and orients to whatever's next. If the previous session left good context, the next agent picks up where you left off.
Walter ideally will tell you when context is getting full. You decide:
- Finish current task: If it can complete before limits, keep going
- Compact: Fine if summary stays coherent
- Fresh handoff: Better for complex work where nuance matters
Use /stash before ending a session to seal the context. It scans for unpersisted work products, asks what to save (defaulting to .walter/), and updates the project config. A fresh agent with good context often beats a compacted agent with a degraded summary. Walter updates the project config (CLAUDE.md, .cursorrules, etc.) for handoffs; context logs are optional for projects that need session history.
The .walter/ directory is Walter's scratch space, gitignored and local. Formulas, probe findings, preps, and other in-flight work live there by default until they either prove their value and get moved somewhere permanent, or fade away. Add .walter/ to your .gitignore when using Walter on a project.
You're the one running the operation. Walter challenges assumptions and demands clarity, but you make the calls. When Walter needs a decision, answer directly. You're the human-in-the-loop whose judgment guides the work.
| Method | Best For |
|---|---|
| Download | Most users. Grab a ZIP from the website, drop the files in |
| Marketplace | Claude Code. Install with one command |
| From Source | Contributors. Clone, build, customize |
Download your provider's ZIP from walter.cooking and extract it. Move the contents of the extracted folder (not the folder itself) into your config directory:
| Provider | Project | Global |
|---|---|---|
| Claude Code | .claude/ |
~/.claude/ |
| Cursor | .cursor/ |
~/.cursor/ |
| Gemini CLI | .gemini/ |
~/.gemini/ |
| Codex CLI | .codex/ |
~/.codex/ |
Codex prompts are invoked as
/prompts:cook,/prompts:trace, etc.
/plugin marketplace add derekherman/walter
Then run /plugin install walter@walter or browse available plugins via /plugin.
To enable agent teams, add to
settings.json:
{
"env": {
"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
}
}git clone https://github.com/derekherman/walter.git
cd walter && npm install && npm run buildCopy built files to your project or global config:
# Claude Code
cp -r dist/.claude your-project/ # or ~/.claude/
# Cursor
cp -r dist/.cursor your-project/ # or ~/.cursor/
# Gemini CLI
cp -r dist/.gemini your-project/ # or ~/.gemini/
# Codex CLI
cp -r dist/.codex your-project/ # or ~/.codex/Apache 2.0
See DEVELOP.md for architecture, build system, provider transformations, and how to add content. See CONTRIBUTING.md for contribution guidelines.