AI coding agents are powerful -- but without structure, they wander. They lose track of the plan. They skip tests. They write code that works but isn't reviewed. They forget what they were doing halfway through.
Other tools try to fix this by locking you into a rigid pipeline: discuss, then plan, then execute, then verify, then ship. In that order. Skip a step? Too bad.
Real work isn't a pipeline. Sometimes you implement three things, then review them all at once. Sometimes you write tests first. Sometimes you skip review on a quick fix and just ship it.
SwissArmyHammer gives you a kanban board and a set of sharp tools. You decide when to plan, implement, test, review, and commit. Every tool is always available. You pick the right one for the moment. No sprint ceremonies. No story points. No enterprise theater. Just tools for people who ship.
┌──────────┐
│ /plan │ Break work into kanban tasks
└────┬─────┘
│ ┌──────────────────────────┐
▼ │ Any tool, any time, │
┌──────────┐ │ any order. │
│/implement│ │ │
└────┬─────┘ │ /test after /implement? │
│ │ /review before /commit? │
▼ │ /implement three tasks │
┌──────────┐ │ then /review them all? │
│ /test │ │ │
└────┬─────┘ │ Your call. │
│ └──────────────────────────┘
▼
┌──────────┐ ┌──────────┐
│ /review │────▶│ /commit │
└──────────┘ └──────────┘
Works with Claude Code, Cursor, Windsurf, or any MCP-compatible agent.
Get Started in 30 Seconds
Get in your project directory and run:
cd <your project directory>
brew install swissarmyhammer/tap/swissarmyhammer-cli
sah init
That's it. Your agent now has skills, tools, and workflows.
Two Ways to Plan
The /plan skill is the front door to SwissArmyHammer. It works two ways:
Hand it a spec
Write your requirements in a markdown file and point the agent at it:
> /plan my-feature-spec.md
The agent reads your spec, explores the codebase to understand what exists, then creates a kanban board with ordered tasks, subtasks, acceptance criteria, and test requirements. Each task has enough context that the agent (or a teammate) can pick it up and implement it without re-reading the spec.
Your spec can be as simple or detailed as you want -- a few bullet points, a full PRD, or anything in between. The agent fills in the implementation details by reading your actual code.
Or just talk it through
You don't need a spec file. Start a conversation and plan interactively:
> I want to add OAuth2 support to the API
The agent enters planning mode, asks clarifying questions, explores your codebase, and builds the kanban board incrementally as you discuss. You can steer the plan in real time:
> Split that auth task into separate tasks for Google and GitHub providers
> Add a task for the token refresh flow -- we'll need that too
> Actually, let's do GitHub first and Google in a follow-up PR
The plan evolves through conversation. Tasks get added, split, merged, and reordered based on your feedback. When you're happy, say "go" and the agent starts implementing.
Then execute
Either way, once the plan is on the board:
> /implement # Do one kanban task at a time, with context-aware code editing and testing
> /finish # RalphLoop one task — or a whole tag/project — through implement → test → review → done. Go for a walk with your 🦮.
> /test # Run tests, report failures as tasks
> /test-loop # RalphLoop test→fix→test until green
> /review # Code review -- findings become new tasks
> /commit # Clean conventional commit
What You Get
The Problem With Other Approaches
Pipeline tools force a rigid sequence: discuss, plan, execute, verify, ship. Every task goes through the same ceremony, whether it's a three-month rewrite or a one-line fix. You can't skip steps, can't reorder them, can't adapt to how the work actually flows.
