How It Actually Works
No demo videos. No hypotheticals. This is what happens when ideas move through the board — from a thought you had at 3am to a thing that exists in the world, with humans and AI agents working on the same cards.
It Starts With a Card
You have an idea. Maybe it's half-formed. Maybe you scribbled it on actual cardboard at 3am. You create a card on the board and write down what you know.
That's it. That's the starting point. No templates to fill, no forms to complete, no methodology to follow. Just write what's in your head. The card holds it.
From here, the card evolves. You add context — links, comments, checklists. You also remove what doesn't belong — a research thread that led nowhere, an approach that didn't pan out. The card isn't a log of everything that happened. It's the curated context for what happens next.
What Builds Up on a Card
You decide what stays and what goes. Unlike a chat where context piles up and can't be edited, the card is yours to shape.
Description
The idea itself. What you want, why you want it. This evolves as you learn more.
Checklists
Break it down into steps. Check them off as you go. Agents check them off too.
Comments
The discussion thread. You talk, agents respond, teammates weigh in. The "why" behind every decision lives here.
Attachments
Research docs, mockups, analysis reports. The agent attaches its findings directly to the card.
Links
Connect cards to each other. Link to pull requests, docs, external resources. Build a web of context.
Activity Feed
Who did what, when. Full audit trail. When someone asks "what happened here?" — you share one URL.
Ideas become plans.
Plans become checklists. Checklists become results.
The Four-Phase Workflow
This isn't a software thing. It's a thinking thing. Whether you're building an app, launching a campaign, planning an event, or organizing your garage — the pattern is the same.
Understand before you act. Plan before you build. Build before you judge. Judge before you ship. Then ship and start again.
Explore
Understand how things are right now
Most people skip this. They have an idea and jump straight to doing. That's how you end up rebuilding things, missing obvious constraints, and wasting time on approaches that were never going to work.
Explore means: look around first. What exists already? What connects to what? Where are the thin spots? What don't you know yet?
For a software project, the agent reads your codebase, maps dependencies, identifies patterns. For a marketing campaign, it researches competitors, analyzes audience pain points, studies what's been tried. For your garage — well, you probably need to take everything out and see what you're working with.
The findings go on the card. Not in a chat window that disappears. Not in someone's head. On the card, where everyone — including future you — can see them.
Plan
Walk through the actions before you take them
Now you know what you're working with. The plan is your walk-through: what do you do first, what comes next, where do you need to be careful, where can you move fast?
The plan becomes a checklist on the card. Not a separate document that nobody reads. A checklist — visible, trackable, checkable. Each item is specific enough that you (or an agent, or a teammate) could pick it up and know exactly what to do.
Bad plans are vague: "improve the homepage." Good plans are atomic: "rewrite the hero headline to focus on the outcome, not the feature." The card forces that clarity because checklist items need to be completable.
A plan on the card looks like this:
Execute
Do the work, one item at a time
This is the part everyone wants to skip to. If you did the first two phases right, this is literally the easiest part of the job. You have a list. Work through it.
You do it yourself. Or you @mention an agent and give it a task. Or a teammate picks up the card. The card holds the context — what's important, what to avoid, what's already been tried. Whoever picks up the work has what they need.
The agent reads the card and does the work. Results go back on the card. If the output misses the mark, you don't start a new chat — you update the card. Remove the bad direction, clarify what you actually want, and run it again. The agent picks up from the corrected context, not from scratch.
Here's the key difference: in a chat, context is whatever you typed in the prompt. If the AI goes sideways, you start a new conversation. With a card, you curate the context — you control what the agent sees. If it goes sideways, you go back, remove the wrong turn, and pick up from where things were on track. You never start over.
Review
Step back and check your work
Did it work? Does it meet the bar? Catch the rough edges before it goes out.
For software, this means security checks, code quality, UX review, documentation. For a marketing campaign, it's brand voice, legal compliance, SEO, platform specs. For your garage — does the car fit? Can you find things?
Review findings go on the card. If something's wrong, you loop back. Maybe you need to re-plan. Maybe you need to research more. Maybe it's a small fix. The workflow is a cycle, not a line.
And then you ship it. Move the card to done. Go back to step one for the next idea. The completed card stays as a record of what was done and why — living documentation that you never had to write separately.
You don't need a methodology.
You need a place to think clearly.
Where the Agent Fits In
The agent isn't magic. It's the same AI you already have access to. The difference is what it gets to work with: a card full of context, not a hasty prompt in a chat box.
You mention the agent in a comment on any card. It reads the card — the description, the checklist, the comments, the attachments, the linked cards. Then it gets to work.
What the agent can do
- * Research a topic and attach findings
- * Break a vague idea into a concrete plan
- * Write code, copy, or drafts
- * Review work from multiple perspectives
- * Check off items and report progress
What you do
- * Curate the card — add what matters, remove what doesn't
- * Define what "good" looks like
- * Set the context the agent works from
- * Make the judgment calls
- * Ship when it's ready
The agent runs in its own workspace. A mistake on one task can't affect another. It works on dozens of cards simultaneously. And everything it does shows up as comments and attachments — fully visible, fully auditable.
Your Tools, Connected
Kardbrd speaks MCP — Model Context Protocol, an open standard for connecting AI tools to data sources. Your board is available wherever you work.
Coding in your editor? Read cards, post progress, check off items — without switching windows. Talking to your voice assistant? Ask it to create a card or move one to done. Using ChatGPT? Connect it to your board and give it the context it needs.
Structured Commands
The four phases come with commands you install in your AI tool. Each one reads the card, does its work, and logs everything back. Repeatable structure, not ad-hoc prompting.
/ke Explore Read before you change /kp Plan Map it before you build it /ki Implement Build it, track it /kr Review Validate before you ship Commands are free and open source. They work with any MCP-compatible tool.
Same Pattern, Different Name
The same four phases. Different vocabulary. Same results.
Software Development
Explore the codebase, plan the changes, implement the code, review for security and quality. The agent writes code, creates PRs, runs reviews.
Marketing
Research the market, plan the campaign, create the assets, measure the results. The agent drafts copy, analyzes competitors, checks brand voice.
Small Business
Understand your operations, plan improvements, implement changes, track outcomes. The agent researches best practices, creates action plans, monitors progress.
Personal Projects
Figure out what you're working with, decide your approach, do the work, check if it's good enough. The card keeps you honest with yourself.
What It Looks Like in Practice
A card in active use is curated, not cluttered. Comments that led nowhere get removed. Attachments that missed the mark get deleted. Plans change when research reveals something new — and the old plan disappears, replaced by the better one.
That's the key difference from a chat. In a chat, context accumulates and you can't edit it. Every wrong turn stays in the conversation, confusing the AI and confusing you. With a card, you go back to where things were on track, remove what doesn't serve the work, and continue from there.
The card holds what matters — not a record of every step, but the refined context that drives the next one. When someone new picks up the card, they see what's relevant now, not the full archaeological history.
This page you're reading right now? It was built on a card. The card held the writing style, the site architecture, the feedback from review. When the messaging was wrong, the card was updated and the agent ran again from the corrected context. That's not marketing — it's just how the board works.
Show your work.
The process is the product.
The Board Adapts to You
You define the lists on the board. You decide what each stage means. Ideas → In Progress → Done. Or Backlog → Research → Building → Review → Shipped. Whatever matches how you actually work.
Cards move left to right as work progresses. The board shows you the state of everything at a glance — what's blocked, what's moving, what's done. No dashboards to configure. No reports to generate. The board is the report.
Multiple people and agents work on the same board. Nobody steps on each other because each card is its own workspace. The board coordinates without meetings.
Ready to see it for yourself?
Create a board. Add a card. Write down what you're working on. That's step one.
Get Started