What is Dybs.it?
Dybs.it is the visual cockpit for the BMad Method — a local-first desktop app that lets one person run a full, disciplined development workflow with a hybrid team: themselves plus a set of AI coding agents.
Think of it this way. The BMad Method is the flight plan — the phases, the agents, the artifacts that carry a project from idea to shipped code. Dybs.it is the cockpit you fly it from: every epic, every story, every phase laid out in front of you, each one a click away from running. You are the agile lead. Dybs.it keeps the whole method visible and one-click runnable.
Note: This page assumes nothing. If the method itself is new to you, read What is the BMad Method? next — the two pages are meant to be read together.
The problem it solves
Start with the job to be done, not the feature list. Ask the uncomfortable question first.
What happens when one person tries to run an AI-native workflow by hand?
They become the single point of coordination. The human holds the plan in their head. They remember which story is ready for dev and which one is stuck in review. They copy the right slash command into the right terminal, in the right order, for the right agent. They track which artifact fed which decision. They are the messenger, the router, and the memory — all at once.
That works for one story. It falls apart across an epic.
The velocity is real: AI agents ship work faster than a human can manually keep track of it. But the coordination stays manual, and the human turns into the bottleneck their own team is waiting on. The orchestrator spends their time being the loop instead of leading it.
Dybs.it's job is to take that coordination off your shoulders. It makes the whole method visible — every phase, every story, every artifact in one place — and one-click runnable, so launching the next step is a click, not a recalled incantation. You stay in the loop without being the loop.
What it isn't
Clearing up three things it's easy to mistake it for:
- Not the method. The method is the open-source workflow; Dybs.it is the cockpit you run it from. You can practice the method without Dybs.it — Dybs.it just makes it visible and fast.
- Not an IDE. Your code editor stays your code editor. Dybs.it directs the workflow — which phase runs next, which agent, which artifact — and hands the actual coding to the LLM CLI you choose.
- Not a generic kanban tracker. It's native to the method's semantics. It knows the difference between a story moving to review and a code-review comment, because those are method concepts, not columns on a board.
Who it's for
Dybs.it is built for the engineer-solopreneur — the agile lead running a hybrid team.
You are someone who:
- Is fluent in AI and fluent in shipping, and already treats your coding agents like a team.
- Wants the discipline of real agile — epics, stories, sprints, reviews — not prompt-rolling.
- Would rather direct the work than hand-carry every status update between phases.
If you lead a hybrid team and want the method to feel like it has a home, this is for you.
What you can do in it
Dybs.it gives you one surface for the whole method. From the cockpit you can:
| Do this | In Dybs.it |
|---|---|
| See your project | Browse Epics and Stories as they move through the phases of the method. |
| Run the method | Launch BMad Method agents in an embedded Terminal — with your choice of LLM. |
| Read and edit artifacts | Open the PRD, architecture, story specs and more in the Documents view, with markdown rendering and automatic file versioning. |
| Work in isolation | Use the built-in Git client and per-story worktrees so each story develops on its own branch without stepping on the others. |
| Pick up where you left off | Resume past LLM work from Session History, recorded per story. |
Two of those deserve a closer look.
The embedded terminal is multi-LLM. When you launch a BMad Method command, you choose the coding agent behind it — Claude Code, Codex CLI, Gemini CLI, Cursor, Aider, Open Code, or any other coding agent that supports the method and runs in a terminal. The method stays the same; the engine is yours to pick. A Command Palette (Cmd+K) puts those commands and navigation a keystroke away.
Worktrees are the default substrate. Every story develops in its own git worktree, so parallel work stays isolated and clean — Dybs.it manages the branch-and-worktree bookkeeping for you.
Tip: Clicking a story's current phase opens a terminal already running the matching BMad Method command. That is the one-click-runnable promise made concrete — the coordination the human used to do by hand.
The live views
The cockpit is a single-page app with a sidebar. Each entry is a view onto your project:
| View | What it shows |
|---|---|
| Epics | Your epics and the stories under each, with their current phase. |
| Stories | Every story and where it sits in the story lifecycle. |
| Intake | New ideas and requests on their way into the plan. |
| Documents | The method's artifacts — PRD, architecture, story specs — rendered and editable. |
| Agents | The roster of BMad Method personas you can launch. |
| History | Past LLM sessions, per story, ready to resume. |
Alongside the views sit the Terminal, the Git client, and Settings — the working surfaces you drop into without leaving the app.
Local-first, and yours
Dybs.it runs on your machine. Your project's data — session history, phase history, intake state — lives under <project>/.dybs/, right next to your code. The method's artifacts live in your repo's _bmad-output/. Nothing about the method requires a server or an account.
To get going you'll want three things:
- Node.js (v18 or newer).
- An LLM CLI — at least one coding agent that supports the BMad Method (Claude Code, Codex, Gemini, Cursor, Aider, Open Code, or another).
- A project with a
_bmad/directory — a BMad Method project for Dybs.it to read.
Note: Dybs.it runs on macOS today, with Windows and Linux on the roadmap. Installation has the current details.
How it relates to the open BMad Method
Dybs.it is the cockpit. It is not the method.
The BMad Method is the AI-native development workflow created by Brian Madison, given to the world as 100% open source — free forever, built by practitioners who ship software every day. Dybs.it honors that: the method is the heart, and Dybs.it serves it.
Open is free tier. Always. The full method and the full visual cockpit are free.
Method by Brian Madison · bmadcode.com · github.com/bmad-code-org/BMAD-METHOD
Tiers, in one breath each
A board for every stage of your hybrid team:
- Free — the full BMad Method and the full visual cockpit, free forever.
- Pro — adds autonomy (Mandate), a mobile companion, full chat history, babysat reviews, and the in-app git client, for when your team should keep shipping past the end of your day.
- Team — adds a web app, a shared team feed, and cross-team status, for hybrid teams where humans lead alongside humans.
This is docs, not a pitch — the point is only that the method never sits behind a paywall.
Next steps
- What is the BMad Method? — the workflow Dybs.it runs, phase by phase.
- Installation — get the app on your machine and open your first project.
See also: The method overview · The agents