How Tinkerbee turns a Spec into tickets your agent can read
A Ready Spec becomes thin tickets in blocked-by order. A read-only MCP server lets Claude Code, Cursor and Codex pull each ticket with its Spec, Decisions, Glossary and ADRs.
Karthik and the Skcript R&E team

A Spec with no gaps is half the job. The other half is getting it into the hands of the thing that writes the code. If your coding agent only ever sees a ticket title, every answer you worked for stays in a tab it never opens.
This post walks through the second half of Tinkerbee: how a Ready Spec becomes tickets, and how your agent reads them over MCP.
Start from Ready
Tickets only come from a Ready Spec. Ready means three things:
- No Open Question is left. Each one is answered as a Decision or deferred on purpose.
- Someone signed it off. The sign-off modal lists what was deferred, the open Todos, and the Glossary terms and ADRs the Spec proposes.
- The Spec is pinned to a commit. From here on, Tinkerbee knows exactly which code the Spec was written against.
That pin matters later, when the code moves.
Check for Drift first
Code keeps moving after sign-off. Someone merges a migration, renames a field, rewrites the capture flow. When you open the Tickets tab, Tinkerbee runs a drift check. It compares the pinned commit with the head of the default branch and keeps only the changes the Spec relies on.
If it finds Drift, it raises Open Questions about those changes only. You have two ways forward:
- Course-correct. Answer the drift questions. Answering the last one re-pins the Spec to the checked commit.
- Continue anyway. Go ahead, and the Spec keeps a "may be stale" badge so nobody forgets.
Deferring a drift question sends the Spec back to Draft, because a Spec with a known hole is not Ready.
Draft thin tickets
The Tickets tab then drafts tickets from the Spec. Each draft is a thin vertical slice: one small piece that works end to end, not a layer. A draft has:
- acceptance criteria,
- the code areas it will likely touch,
- what it is blocked by,
- a size,
- and a mark, AFK or HITL.
AFK tickets can run with nobody watching. HITL tickets need a human in the loop. Any ticket that depends on a deferred Open Question is HITL, because the answer it needs does not exist yet.
Editors review the drafts. They edit, reorder, drop or add tickets, and set an assignee and a priority. Then they save, in one action. The tickets keep their blocked-by order and carry the Spec ID, and the Spec becomes Ticketed.
Ticketed is final
A Ticketed Spec is frozen. No edits, no grill rounds, no Tinker ✨, no new Decisions, and no way back to Draft. Comments, Todos and ticket assignees still work.
That sounds strict. It is on purpose. An agent halfway through ticket 3 should never find that ticket 2's Spec changed under it. If the plan really changes, write a new Spec.
Hand them off
Today you can copy the tickets as Markdown and paste them wherever your team tracks work. Sending them straight to Knol is next.
Your agent reads the Spec over MCP
Tickets are short on purpose. The detail lives in the Spec, and your agent fetches it through the Tinkerbee MCP server at https://api.tinkerbee.io/mcp.
The server is read-only. It has six tools:
| Tool | What it returns |
|---|---|
list_specs |
Specs on the repos you can access, with Spec ID, title and status |
get_spec |
A Spec's text, its Decisions, its deferred Open Questions, and the Glossary terms and ADRs it relies on |
list_tickets |
The saved tickets of a Spec, in blocked-by order |
get_ticket |
One ticket, like SPEC-12-3, with its full Spec |
get_glossary |
Every term in the repo Glossary, with the words to avoid |
get_adrs |
The repo's ADRs, by number |
get_spec returns deferred Open Questions on purpose. An agent that knows where the known gaps are can stop and ask at the right moment, instead of guessing at the wrong one.
Adding it takes one command in Claude Code:
claude mcp add --transport http tinkerbee https://api.tinkerbee.io/mcp
Then run /mcp and sign in with GitHub. Codex is two commands:
codex mcp add tinkerbee --url https://api.tinkerbee.io/mcp
codex mcp login tinkerbee
In Cursor, add the URL to ~/.cursor/mcp.json and click Connect. The Connect your agent page in Tinkerbee has all three, ready to copy.
Signed in as you
The agent signs in through standard MCP OAuth with your GitHub identity, and you approve it once in the browser. It sees exactly the repos you can see on GitHub, and nothing else. Lose access to a repo on GitHub and your agent loses it too.
Some things stay in Tinkerbee. Todos, the Flow tab and ERD fit are for the people writing the Spec, so the MCP server does not expose them.
MCP reads never count against anyone's Token cap. Your agent can read the Spec as often as it needs to.
What a run looks like
In practice, you tell your agent to build SPEC-12. It calls get_spec, finds four Decisions and one deferred question, reads the Glossary terms for Refund and Capture and the ADR about refund limits, then starts on ticket 1 of 3. When it reaches the deferred question, it can stop and ask you, because it can see that no answer exists yet.
That is the whole idea. Answer the questions once, in the Spec, and let the agent read them.
Try it
Tinkerbee is in beta, and it is a Skcript R&E project. Sign in with GitHub to request access, or email business@skcript.com. The first half of the story is in Specs with no gaps: why we built Tinkerbee.