SwissArmyHammer

Manage AI prompts as local markdown files.

A multitool for agent-driven engineering.

Every tool, any order. It's a multitool, not a pipeline.

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.

cd <your project directory> brew install swissarmyhammer/tap/swissarmyhammer-cli sah init

That's it. Your agent now has skills, tools, and workflows.

The/planskill is the front door to SwissArmyHammer. It works two ways:

Write your requirements in a markdown file and point the agent at it:

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.

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.

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

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.

SwissArmyHammer is different. Every stage of the software development lifecycle is an independent tool. Use what you need, skip what you don't. The kanban board is the shared state -- not a sequential pipeline.

These tools connect into loops./plancreates tasks./implementworks through them./reviewfinds issues and appends them as checklist items on the source task./finishruns implement → test → review in a loop until each task lands indone./coveragefinds untested code and creates test tasks. It's a closed loop -- but you control the order.

The biggest bottleneck for AI agents isn't intelligence -- it's context. Long test output blows the context window. The agent can't find the function it needs. It re-reads files it already scanned. SwissArmyHammer solves this at every level.

The built-in shell isn't a thin wrapper around subprocess exec. It's avirtual shell with persistent history, process management, and searchable output:

- Every command's output is stored and indexed-- even if the response was truncated to save tokens
- Semantic search across all output-- ask "find the authentication error" and it matches "403 forbidden" and "login denied"
- Regex grep across history--error\[E\d+\]finds every Rust compiler error from every command you've run
- Line-range retrieval-- output was truncated? Fetch lines 450-500 of command #3 without re-running it
- Configurable output limits-- return 50 lines, 200, or zero (fire-and-forget). Full output is always saved for later

This means your agent can runcargo testwith 10,000 lines of output, get a 50-line summary, and then surgically search for the failure -- without burning context tokens on scrollback.

Automatic Code Intelligence (tree-sitter + LSP)

SwissArmyHammer automatically indexes your codebase using tree-sitter and LSP. No configuration, no manual setup -- open a project and it starts parsing in the background.

- Symbol lookup-- jump to any definition with fuzzy matching (MyStruct::new,process_req, partial names)
- Call graph traversal-- who calls this function? What does it call? Trace execution flow across files
- Blast radius analysis-- before you changevalidate_token, see every file and function transitively affected
- Semantic diffs--git diffshows line changes; sah shows entity-level changes (Added, Modified, Deleted, Moved, Renamed)
- 25+ languages-- Rust, Python, TypeScript, Go, Java, C/C++, Ruby, Swift, Kotlin, and more

This is what lets/planactually understand your codebase before creating tasks, and what lets/reviewcatch real architectural issues instead of just style nits.

SwissArmyHammer is three tools that work together:

The core. An MCP server that gives your agent everything it needs:

Skills-- the workflows that use those tools:

Skills are markdown files. They teach your agenthowto do things, not justwhatto do. Each skill defines a step-by-step process, and a specialized agent type executes it. This is what turns a generic LLM into a focused engineer.

You can write your own skills too -- drop aSKILL.mdin.sah/skills/my-skill/and your agent picks it up automatically.

Everything is markdown.Skills, validators, workflows, agents -- all markdown with YAML frontmatter and Liquid templating. No proprietary formats, no databases, no cloud lock-in. Everything lives in your repo or your home directory, fully version-controllable.

~/.sah/ skills/ # Installed skills (markdown) validators/ # Installed validators (markdown) agents/ # Agent modes (markdown) workflows/ # State machine workflows (markdown + Mermaid)

Project-level overrides go in.sah/in your repo. Project settings win over user settings.

The MCP server itself is a single Rust binary -- fast startup, no runtime dependencies, no Docker, no cloud services. It runs locally alongside your agent.

For individual developers:Your agent becomes dramatically more capable. Instead of babysitting it through each step, you hand it a spec and walk away. It plans, implements, tests, reviews, and commits -- following the same engineering process you would.

For teams:Consistent engineering process across every developer's agent. The same skills, the same validators, the same quality gates. Install once viamirdan, and every team member's agent works the same way.

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

AI-powered reading triage MCP. 26 tools with a 24h burn timer. Read less, absorb more.

An AI-powered documentation management system with hierarchical context management and session continuity.

List and create Manthan concept-card decks from an AI agent — no AI quota spent for imports.

Let AI read, search, and summarize your UpNote notes — and create new ones — right from your chat.

Hebbian memory for AI agents — learns file access patterns, builds neural pathways, predicts next tools/files, saves tokens

Create notes, search, & think with your Fabric AI workspace

Production-ready RAG out of the box to search and retrieve data from your own documents.

Official Notion MCP server for searching, reading, creating, and updating Notion pages, databases, and workspace content from AI agents.

Prompt Buddy MCP exposes a public, searchable catalog of reusable AI skills.