Kanban, wiki and roadmap, for people and agents

One place for all your team's work, and the agents doing it.

Slipdock is a kanban board, a wiki and a roadmap in one, and a good one whatever your work is. Cards that can become boards of their own, seven customisable views, automations you write in plain English, and semantic search. Drive it yourself, from your phone, or with your AI agent. To-do lists, agile sprints, scrum; however you like to work. Built to replace a stack of bloated commercial tools, and it costs nothing.

If you build software, all of it lives here. The cards your agents are building sit beside the reviews your team owes. Runners on your own machines work your lists in order, the board checks what they say they finished, and what each card teaches goes into a handbook the next card reads. See how

Free forever with every feature, up to 200 cards.

Kanban lists drawn as dock slips, with an orange card sliding into a berth
A Slipdock board with Backlog, To Do, In Progress and Done lists, each card showing tags, flags, dates and progress
Fig. 1 A board. Tags, flags, dates, checklists and roll-up progress, all on the card face. And if you just want a great to-do list, you can switch off the extras. Your choice.

Never again

How would you like to never do these things again?

  1. 01

    Keep one backlog for your big ideas, and a completely separate one for the nitty gritty.

    Any card can become a board of its own, so the idea and every task under it live in one tree, and progress rolls up.

  2. 02

    Write the stakeholder update.

    Post a status on a card in a click. The Narrative view tells anyone what happened to a set of cards over any date range.

  3. 03

    Ask your exec team to vote on the roadmap in something too complicated for them to use.

    Budget voting sits right on the Prioritise view: everyone gets a set number of votes to spend. Share the board and they are in.

  4. 04

    Copy the backlog into a spreadsheet to plan the sprint, then draw the burndown by hand.

    Add cards… lays out every list you plan from at once, with priority, RICE scores, votes and estimates, and keeps a running total as you tick. Burndown and velocity draw themselves.

  5. 05

    Write an integration so that X happens whenever Y does.

    Write a sentence instead. "When a card lands in Done, email ops@example.com" becomes a rule the app runs for you.

  6. 06

    Learn yet another project management tool.

    Lists, cards and pages. Want only a to-do list? One tick turns a board into exactly that. Your first sign-in comes with a Getting Started board that explains the app using the app.

Slipdock puts an end to all that.

Because it is built by people who build software in the real world. The world where work ends up spread across lots of lists, where the stakeholders are demanding and will not use your systems, and where every new tool costs you time learning concepts you never needed.

Built to replace

Kanban boards
TrelloFizzyAsanaMonday.comClickUpWrikeBasecampMicrosoft PlannerMeisterTaskBusinessmapSmartsheetTaigaWekanPlanka
Issue and bug tracking
JiraLinearGitHub IssuesGitLab IssuesAzure DevOps BoardsYouTrackShortcutBugzillaRedmineMantisBT
Roadmaps and discovery
Jira Product DiscoveryAha!ProductboardProductPlanRoadmunkAirfocus
Wikis and docs
ConfluenceNotionCodaSlabNuclino
Homegrown trackers
Notion project databasesObsidian project vaultsThe project spreadsheet
Status updates
AtlasRangeStatus HeroThe weekly status email

01  Plain English

Tell it what you want, or have your Agent tell it for you.

  1. Automate Flag any card that is more than 3 days overdue as urgent, and email jane@example.com.

    A model reads the sentence once and writes the rule. From then on the app runs it, on every change and on a timer. The common ones are ready-made: pick one, fill in a form, no model needed.

  2. Command Split this card into 3 sub-cards.

    Edit mode shows you exactly what it will change. Nothing applies until you say so.

  3. Ask Across all my boards, what tasks are slated to take less than a day?

    It searches every board you can see, then answers the question in prose.

  4. Find Where is the card about the invoicing bug that came in last week?

    Search by meaning, comments and status updates included. The card never has to say "invoice".

Your key, your call The AI features run on your own OpenRouter key, or on any OpenAI-compatible model you run yourself (LM Studio, Ollama, llama.cpp, vLLM), so nothing leaves your network. Neither one, no AI features, and nothing about your boards is sent anywhere on your behalf.

02  Subcards

Any card can become a board of its own.

An epic and its tasks live in one place, nesting as deep as the work does. Open a card and you are on its board; close it and everything below rolls up to the card face.

Leaves done, effective dates, slip, anything blocked further down, and a health pill computed from all of it. The outline view shows the whole tree at once, and My work gathers everything assigned to you across every board.

03  Only what you need

A shopping list or a sprint. Use as much of it as the job wants.

Everything past a to-do list is optional. Sprints, estimates, health reports and dependencies wait until you go looking for them, and a single setting on a board puts all of them away.

  1. One tick

    Just a to-do list

    Tick Simple board in a board's settings and it becomes a plain to-do list. The project machinery leaves the card, the badges leave the tiles, and two views leave the menu:

    • % complete
    • Start dates
    • Health
    • Time tracking
    • Votes
    • Dependencies
    • Timeline
    • Prioritise

    Title, due date, priority, tags, checklists, assignees and comments all stay. Nothing is deleted: untick it and everything comes back. Subcards made on a simple board start simple too.

  2. The default

    A project

    Subcards that roll up, dependencies, health and the timeline, for work with more than one moving part.

    Time tracking is there if you want it: a timer on the card, time spent against an estimate. Ignore it and it stays out of the way.

  3. Opt in

    Sprints

    Make a sprint board and each card on it is a sprint. New sprint dates the next one, and Add cards… plans it from your backlogs, with scores, estimates and running totals side by side.

    A Charts button draws each sprint's burndown and the board's velocity.

    No sprint board, no sprints. Nothing elsewhere changes.

04  Views

Seven views of the same cards.

Nobody keeps a second copy. Each view has its own filters and display options, and any of them can be saved, shared or published.

The board view of a Slipdock board
Fig. 2.1 Lists and cards. Drag, drop, flag, and see roll-up health at a glance.

05  Wiki

The documentation sits beside the work.

Every board can carry a wiki. Every card can carry one too. Markdown pages in a tree of folders, with [[links]], live card chips, live query blocks, backlinks, revisions, templates and public links.

So the decision about pricing is a page attached to the pricing cards, not a document in another product that nobody can find in six months.

A wiki page called Launch runbook, beside the board it belongs to
Fig. 3 A runbook, filed on the board it runs.

06  MCP, API and CLI

Agents work the board the way a person does.

Slipdock is an MCP server, so your AI agent can work your boards directly. Chat about your work, have it create the cards, and run loops off the back of them. And you get a JSON API and a command line tool too.

  • In Claude or any other AI app that supports MCP, add https://app.slipdock.us/mcp as a custom connector, sign in and approve it.
  • Its tools read, search, add, move, comment on and complete cards, and write wiki pages.
  • Tokens can be read-only, confined to named boards, and set to expire. Revoke any of them at any time.
  • The server ships agent skills, and /api/guide describes your boards to whatever is driving them.

Never again, when agents write the code

How would you like to never do these things again?

  1. 01

    Watch an agent all afternoon in case it decides done means something you never asked for.

    Write the bar first. The card says what done means, the bar locks when work starts, and the agent is measured against it.

  2. 02

    Untangle two agents that edited the same files and committed each other's half-finished work.

    Lanes. Each card names its paths, an overlapping card waits its turn, every job can get its own worktree, and a pre-commit hook keeps each commit inside its card.

  3. 03

    Take an agent's word for it that the tests pass.

    No evidence, no completion. The agent says which tests it ran, the result and the commit, and a second agent or a person checks before the card counts as done.

  4. 04

    Keep a terminal open all day, feeding an agent the next ticket.

    A runner on your own machine works the list from the top, in the order you stacked it, and parks the card with a question when it needs you.

  5. 05

    Scroll through a hundred comments to find out where the last session left off.

    Every card carries a handoff: the next step and a short note, left by whoever stopped, person or agent.

  6. 06

    Build a spreadsheet to prove to leadership that delivery is getting faster.

    Wrap your deploy step in one command. Deployment frequency, lead time, failure rate and idea to production work themselves out.

  7. 07

    Keep the reviews you owe in one tool, the agents' questions in another, and their work in a terminal.

    Waiting on you gathers all of it from every board, oldest first: the questions agents asked, cards to review, runners in trouble, and work in progress that nobody is on.

  8. 08

    Field an agent's product question that should have gone to your product owner.

    A question says what kind it is (product, UX, security or release), and the board sends it to whoever owns that call, with a suggested answer, so replying can take one click.

  9. 09

    Explain the same gotcha to a fresh agent every week.

    What a card teaches is kept on the board. Settled knowledge goes into the handbook, and every card starts with the sections and rules that cover its files.

Built to replace

Boards for coding agents
Vibe KanbanBacklog.mdTask MasterKanban CodeKanBotsNimbalyst
Parallel agent runners
ConductorClaude SquadParallel CodeSupersetThe tmux session full of agents
Delivery metrics and DORA
LinearBSwarmiaSleuthJellyfishDX
Homegrown agent plumbing
The TODO.md the agent keepsThe handoff note in the repoThe cron job that feeds it the next ticketThe memory file only one laptop can read

How it works

07  Shipping software

Let agents build. Check what they say they finished.

Runners on your own machines take cards from a list, one at a time, in the order you stacked them. A board can then hold that work to a standard: a bar before it starts, its own files while it runs, and proof and a second opinion before it counts as done.

  1. 01Plan

    From an idea to cards.

    Ask an agent to plan something and it sizes the ask first: one card, a feature or a system. It asks what it needs to, writes the decisions and principles into the handbook, and puts a spec on the epic and the cards beneath it. A one-line ask stays one card.

  2. 02Bar

    Say what done means before it starts.

    A card carries a bar: what done means for it. An agent can't start a card without one, and once work starts the bar locks. Agents can't move the goalposts. A person still can, and the change is logged.

  3. 03Lanes

    Parallel agents, separate files.

    A card lists the paths it will touch. An agent can't start a card that overlaps one already in progress, so the runner takes the next card instead. Each job can get its own git worktree, and a pre-commit hook refuses a commit that strays outside the card's paths.

  4. 04Evidence

    Done comes with receipts.

    An agent completing a card says what it checked: the tests it added, the suite's result, the branch and the commit. No evidence, no completion.

  5. 05Verify

    Somebody else marks the homework.

    Completion becomes a submission. A second agent, on a different runner, or a person accepts it or rejects it with a reason. The builder can never accept its own work. A rejected card goes back to the top of the list with the reason in its next prompt, and counts how often it bounced.

  6. 06Ship

    By push, or by pull request.

    A board ships straight to the default branch, or by pull request. On a pull request board, accepting the card has a runner merge it, and the merge completes the card.

  7. 07Tier

    Some changes wait for a person.

    Each card has a profile: security, schema, feature, fix, docs or spike. It is checked again against the change itself and only ever raised, and the board says which profiles merge on an agent's word and which wait for a person. Out of the box, schema, security and spike wait.

  8. 08Measure

    Shipped, and counted.

    The ledger says what shipped since yesterday, who accepted it and what its jobs cost. Wrap your deploy step in one command and the board records every deploy and reports its DORA numbers, idea to production included.

  9. 09Incidents

    When it breaks, ask which check missed it.

    An incident names the card that caused it and the check that should have caught it: the bar, the rules, CI or the verifier. That lesson goes back to the board like any other.

And around the edges

  • Runners dial out. Slipdock never calls your machine, so there are no ports to open, and what each kind of job runs is set on the runner, not the server.
  • An agent that needs a person asks on the card and parks. Answer it and the card goes back to work, with your answer at the top of the prompt.
  • A card that stops short leaves a handoff: the next step and a short note, for whoever picks it up.
  • The owner can pause a whole board tree with a reason. Agents can pull the brake, but only a person releases it.

08  Learning

It gets better at your project with every card.

Agents forget. The board doesn't. What a pass learns is written down where every later pass, the verifier and every other machine can read it, not in one agent's memory on one laptop.

  1. 01Handbook

    A handbook for the project.

    One command puts a handbook on a board: specification, architecture, UX, data model, testing, operations, principles and a page for each decision. A seed card drafts it from your code, and a weekly card catches drift.

  2. 02Brief

    Each card starts with what it needs.

    Before an agent builds, the card hands it the handbook sections that match the work and the rules that cover its files, each rule with how it will be checked.

  3. 03Findings

    Every card says what it taught.

    A pass closes with what it found: a gotcha, a candidate rule, a page the handbook got wrong. The server adds its own, from rejections, timeouts and failed merges.

  4. 04Rules

    Lessons become rules, with a person's say.

    A daily triage merges findings, promotes them into the handbook or dismisses them. A lesson that keeps coming back is drafted into a rule, and the rule waits for a person to accept it.

  5. 05Watch

    Something keeps an eye on the outcomes.

    The health monitor finds stuck work and fixes it where a safe fix exists. The overseer notices work going round in circles, idle runners beside a full list or a board waiting only on you, and says why and what to do.

  6. 06See

    The whole operation on one page.

    Right now shows every runner and what it is doing, and every queued job with why it is held. Visualise draws the flow, and its quality numbers say whether the loop gets things right first time.

09  And the rest

The details that decide whether you keep using it.

LiveEveryone sees the same board
Built on Phoenix LiveView, so every browser looking at a board updates the moment anything changes. No refresh button.
PlanningRoadmaps without a second tool
Dependencies with cycle detection, milestones, list horizons, formula fields for RICE and ICE, budget voting, typed links and goals.
SharingShare exactly what you mean to
Passwordless sign-in and groups. Read-only or editable grants on a whole board, a single card, one wiki page or a saved view.
PortableNothing here is a one-way door
A whole board tree exports to one JSON file that another Slipdock reads back: cards, subcards, fields, dependencies and the wiki. Trello boards import as they are.
TimeTime tracking on the card
A timer, time spent and an estimate, in minutes through to months. The bar turns amber near the estimate and red past it.
TeamsEveryone on the card who is on it
As many assignees as a card needs, each with a swimlane of their own. Type @ in a comment and the person named gets an email with a link.
NarrativeThe update writes itself
Pick a set of cards and a date range, and the Narrative view tells you what happened to them. Stakeholders get a story, not a ticket dump.
OnboardingA tour made of the thing it explains
Your first sign-in comes with a Getting Started board: a dozen real cards, an epic, subcards, a working automation and three wiki pages.
A Slipdock board on a phone, one list at a time with a bottom navigation bar
Fig. 4 Below 640px it becomes a pager, not a sideways scroll. On a desktop, there is a command palette and a key for every board.

Getting aboard

Free to use.

Hosted

app.slipdock.us

Free forever

Every feature, nothing held back, for up to 200 cards. Sign in with your email and you are on a board in under a minute.

The limit counts cards on boards you own. Working on someone else's board costs you nothing.

Start on a board

A word on how it was made

Built with AI. Not vibe coded.

Of course AI wrote a lot of it. But Slipdock started from three decades of managing projects and writing software, was planned before it was built, is held up by a serious test suite, and has been security reviewed by several different coding agents. It was made for a real job: running real projects, every day. And it is planned, built, checked and shipped on its own board, by the loop on this page.