Putting a team on it

“Smaller than Jira” is a claim, not evidence. This page is the evidence: the whole surface listed, so you can work out what it costs your team’s week.

If other people will use this, read this page first. If the arithmetic looks right, Coming from Jira is the comparison and Try it in ten minutes is the proof.

First, two words this site keeps using

Skip if you know them.

A coding agent is an AI that edits your code directly: Claude Code, Codex CLI, Antigravity and others. It reads your files, changes them, and runs commands. Where a chatbot shows you a change, an agent makes it.

MCP is the standard those agents use to reach tools outside themselves. If an AI can read your calendar or query your data, this is usually how. tuckit publishes its board this way, which is why an agent can read and update it without anyone writing an integration.

Anyone who only uses the web page needs neither. Only the person attaching an agent does.

The whole vocabulary: four words

Word	What it is	How many you’ll have
Org	The container in your account. Names your addresses and card numbers	One per project or company
Area	A broad heading: frontend, backend, docs	Two or three to start
Card (Slice)	One piece of work, from “this matters” to finished	Most of your board
Steps	The ordered list inside a card	A handful per card

There is no fifth. No lighter object to jot into, no heavier one to graduate to. A passing thought and a quarter’s work are both cards, and the difference is how much has been written into one.

Inside a card, three boxes do three different jobs. That’s all the structure there is.

Box	Tense	The question it answers
Spec	Future	What are we building, and why?
Constraints	Standing	What must never go wrong?
Activity	Past	What actually happened?

That’s the model. What’s on the screen is the same thing at length.

What a person decides: three things

Only three things on the whole board need somebody’s judgement.

1. What we’re building (Spec).
2. What must not break (Constraints).
3. That it’s finished. The one status change nothing else can produce.

Everything else is either derived from those or is tidying you can undo.

Reversible tidying, which you and your agent can both do: filing a card into an area (clear it and the card returns to the Inbox), adding and ticking steps, assignee, tags, ordering. Nothing here is one-way, so nobody has to be careful.

Nobody sets these, ever:

• Stage. How far along the work is, worked out from the card’s own contents.
• Which board column a card sits in. Stage decides, which is why cards don’t drag: you can’t drag a card into having been worked out.
• The card number (ACME-42). Assigned per org when the card is made.
• Progress. It’s the steps that are ticked, and nothing else.

What doesn’t exist, so nobody has to learn it

None of this is “not yet”. These concepts are absent from the model, and your team will never be asked to have an opinion about them:

• Sprints, iterations, velocity
• Story points, estimates, time tracking
• Epics, and issue types (no bug/story/task distinction, no sub-task types)
• Custom fields
• Configurable workflows, state machines, transition rules, required fields
• Resolution types
• Components, fix versions, release objects
• Permission schemes and issue-level security
• Board configuration: swimlanes, quick filters, saved views
• Report builders, burndown and velocity charts
• Automation rules

Some of those your team genuinely uses. That’s a real reason not to adopt tuckit, and Coming from Jira says so at length rather than talking you out of it.

Setup cost, per person

Once, and it doesn’t recur:

1. Sign up at app.tuckit.dev with email and password, or Google, or GitHub.

2. Two lines in their coding agent. For Claude Code, literally:

   /plugin marketplace add tuck-it/tuckit-plugins
   /plugin install tuckit@tuckit-plugins

3. Press Allow on a browser screen the first time the agent uses tuckit.

There’s no long string to generate, copy, store, rotate or paste into a config file, at least on the common path. The credential lands in the operating system’s keychain and refreshes itself. Connect your agent covers the other AIs, and the one case (Codex today) that still needs a token.

What each role learns on day one

Someone who only opens the web page, a PM or a designer or a founder checking where things are, learns four words and one sentence: an empty “what we’re building” box means it hasn’t been worked out yet. That’s the whole onboarding. They’ll read the board correctly on their first visit, because the columns reflect the state rather than a workflow somebody configured.

Someone attaching an agent also learns the two words above and types two commands. They don’t have to learn the eleven MCP tools; the agent reads those from the server.

Whoever sets it up for the team learns one more thing: areas are broad headings, not features. If you’re making an area per feature, you wanted a card. It’s the most common early mistake and it’s fixable in a click, because moving cards between areas is free.

What actually takes learning

Four things. Nobody absorbs them from a feature list.

People conflate Status and Stage. Status is a call a person made (open, shipped, dropped) and it’s stored. Stage is what the work needs next (needs_design → needs_steps → executing → ready_to_ship), worked out on the fly and never stored. Read progress from Stage, decisions from Status. Ten minutes on the long version is worth it before anyone builds a habit on the wrong one.

Writing back at the end is the real cost. tuckit only stays true if decisions land on the board instead of in a chat log. The plugins install a reminder, and a reminder isn’t enforcement. This is a discipline, not a feature, and it decides whether the board is worth opening in three weeks. Budget two or three sessions for it to stop feeling like an extra step. The daily loop is that habit written down.

People fight the empty box. Every other tracker rewards filling the form in. Here, an empty Spec is how the board says nobody has worked this out, and it’s the first thing an agent notices. Filling it with a rough note makes un-designed work look designed, to you and to every agent you attach.

People make an area per feature. The mistake above. Easy to fix, but it takes weeks to notice.

Realistically

What’s on the screen takes about ten minutes and is the only reading anyone needs. Setup is under five. The habit takes two or three sessions.

The part nobody can shorten for you is deciding whether a model this small fits how your team works, which is the next page.

Where to go

• Coming from Jira: the mapping, what you give up, and when Jira is still right.
• Try it in ten minutes: a board and an attached agent.
• What’s on the screen: the four words in full.