Install · How you use it · The pipeline · Privacy · GitHub

Boots is the companion that helps you finish AI systems.

A build-and-close pipeline for Claude Code and Claude Cowork.

I kept starting AI systems and never finishing them. A skill half-built in one chat, an idea clarified in another, a tool that "worked" only because I remembered its tricks — all scattered across sessions I'd never reopen. Every toolkit I tried helped me start faster, which just gave me more half-built things. So I built the part that was missing: the one that closes. Boots is what I use to make finishing the default.

If your AI tool is the builder, Boots is the finisher.

Boots is a suite of skills that keeps track of every AI system you have going, tells you the one next step, and walks each one from a fuzzy idea all the way to a finished, usable tool. Bring a half-formed ambition; Boots works out where you actually left off, in your own words, and moves it forward one concrete step at a time.

It runs on Claude Code and Claude Cowork, and builds whatever that tool can build — the shapes on offer differ between the two, and Boots knows which ones you have.

Every builder toolkit helps you start. Boots also closes — review it, prove it works, and ship it are real steps, because a system isn't done until it's actually shipped.

The failure mode Boots fights is abandonment. People start systems and forget them. Boots makes forgetting impossible and finishing the default.

	Step	Example
01	Clarify	"I want AI to grade the freelance editors applying to my brand." → a real outcome.
02	Scope & build	Cut to the smallest useful version, pick what to build (a skill, an automation, a script…), build it.
03	Close	Review what's wrong, prove it actually runs, ship the finished tool.

How you use it

You don't memorize a pipeline. You say one word:

boots

Boots looks at every system you have going, checks what it remembers against what actually got built, and tells you the one next step — in your own words, not a stage name. Do that step, say boots again, and it moves you forward. That's the whole loop.

The stages below run in an order, and Boots knows it so you don't have to. Say boots, then just describe the idea — Boots reframes it, cuts it down, builds it, checks it, proves it, and ships it, offering each next step in plain English as you go. You never type a stage name. (You can invoke a stage directly if you want the manual controls, but you never have to.)

Why this matters if you don't code: every other builder toolkit hands you a menu of commands and expects you to know which one, in what order. Boots holds the order for you. The only command you have to remember is boots.

See it work

A full build, stage by stage. Run each stage yourself like this — or just say boots and it drives the whole pipeline for you, offering each step in plain English.

You:    I want AI to grade the freelance editors applying to make reels for my brand.
You:    boots-clarify

Boots:  I'm going to push back on the framing. You said "grade editors" — but grading
        isn't the hard part; you can already tell a good reel from a bad one. What you
        actually want is a taste-first shortlist: the eye decides it, editing is a floor.
        [reframes the problem, spells out what it really needs to do]
        [writes down what you're really building, in your own words]

You:    boots-scope
        [cuts to the smallest useful version: read each CV + links, open their real
         reels and Instagram, rank on taste, return a shortlist with one line each]
        [picks what to build: a skill. Scoring dashboards + auto-emails → left for later]

You:    boots-build
        [builds the skill and drops it in place — a few minutes]

You:    boots-review
        [FOUND] it grades from the CV text instead of opening the reels — defeats the point
        [AUTO-FIXED] now opens the real work first and judges the eye

You:    boots-verify
        [runs it on 3 real applications, end to end — top pick matches your gut]
        [GAP] two portfolios were behind a Linktree; clicked through by hand

You:    boots-ship
        [heals the Linktree gap into the skill so it handles them itself next time]
        Shipped. Ran clean on all 3. "reel-scout" is a real skill now — invoke it any time.

You said "grade editors." Six commands later you have a taste-first talent scout that opens real work, ranks it, and improved itself along the way. Or skip the commands entirely — say boots and it walks the same pipeline for you.

Builds any form

Skill

Agent

Slash command

Automation

Connector

App

Script

Notes

Boots builds whatever the job needs — picked from the work itself, not from whatever project you happen to be in.

Boots is right for you if

• ✅ You start more AI systems than you finish and lose track of the half-built ones
• ✅ You want a companion that remembers where every system stands and always has the next step
• ✅ You build with Claude Code or Claude Cowork and want everything it can build — skills, agents, automations, scheduled jobs, connectors, scripts — treated as real work, not just loose files
• ✅ You want the closing work — review it, prove it works, ship it — to be a real process, not a vibe
• ✅ You want a pickup to feel like the last chat never closed — your situation in your own words, not a stage name
• ✅ You want Boots to dig through your old chats, notes, and to-do lists for work worth building

Features

🧭 One next step Boots looks at everything you have going and gives you a single concrete move — not a status dump.	🏁 It actually finishes Review it, prove it works, and ship it are separate, deliberate steps. A tool isn't done until it's really done.	🧱 Any form Whatever the job needs — a skill, an agent, an automation, a connector to another tool, a script, or a piece of reference.
🔗 Picks up where you left off Open a new chat and it feels like the last one never closed — Boots starts you back in your own situation, in your words.	🩹 Never loses your progress If a chat did the work but forgot to write it down, Boots spots what actually got built and catches its record up — so you never redo a finished step.	⛏️ Finds work worth doing Boots digs through everywhere your unfinished ideas pile up — past chats, notes-to-self, to-do lists, other AI tools — and hands you a ranked list.
🧠 Gets smarter each time Every finished tool teaches Boots something it applies to the next one — your work builds on itself instead of starting over.	🧹 Knows when to let go When a system's gone cold, Boots suggests dropping it — so your list stays honest, not a graveyard of things you'll never finish.	📁 Remembers everything for you Nothing has to live in your head between steps. Boots keeps its own running notes so you can walk away and pick up cold.

Problems Boots solves

Without Boots	With Boots
❌ You start ten AI systems and finish two. The rest rot half-finished across old chats you'll never reopen.	✅ Every system is tracked with where it's up to and its one next step. Abandonment becomes visible and fixable.
❌ You open a chat and spend ten minutes re-deriving where you left off.	✅ Boots opens with exactly where you left off, in your own words — the pickup feels like the same chat.
❌ A tool "works on your machine" because you carried its tricks in your head.	✅ Boots writes down every step you did by hand, then folds each one into the tool itself before it's done — so it works without you next time.
❌ "What should I build next?" has no grounded answer, so you thrash.	✅ Boots digs through your old chats, notes, and to-do lists and hands back a ranked list of what's worth building, with the reason for each.
❌ You build the same class of thing twice because the last lesson stayed in a chat.	✅ Boots captures what each finished tool taught and applies it next time — so you don't rebuild the same thing twice.
❌ "Done" means "it ran once," so half-finished tools pile up as finished-looking ones.	✅ Done means reviewed, proven to work, and shipped. Boots won't let a system fake completion.
❌ A shipped tool quietly breaks — runs fine but gives the wrong answer — and you find out weeks later, by accident.	✅ Boots keeps watching live systems: whenever you open it, it checks each one still works and still gives the right answer, then evolves it with you.

Why Boots is special

Boots handles the unglamorous "finish it" details correctly.

• It really finishes. Reviewing, proving it works, and shipping are different jobs, so Boots does them as separate steps — nothing gets a single "looks done" rubber-stamp.
• It trusts reality, not its notes. Before Boots tells you where things stand, it checks its own notes against what actually got built — and if they disagree, what's real wins.
• It builds the right kind of thing. Boots picks what to build from what the job actually needs — not from whatever the project you're in happens to be made of.
• It proves things really work. "Works" means Boots actually runs the thing the way you would — not just "the tests passed."
• Nothing you did by hand is forgotten. Every manual step you took to make it run gets built into the tool — or noted out loud as left for later — before it ships.
• Lessons stick. When a finished tool teaches you something, Boots doesn't just remember it — it changes the tool to obey it.
• Shipping isn't the end. Boots keeps watching live systems and checks the answer, not just that the job ran — because a tool can run green and be silently wrong. When it drifts, Boots evolves it with you.

The pipeline

A system moves through steps. Each step is a skill. Each one writes down what it did in a plain notes file; the next one reads it. Nothing lives in your head between steps.

   clarify → scope → build → review → verify → ship
                               └───────── the closer ─────────┘

   run any time:
   prospect · track · surface · rethink · observe · extract · retire

After a system ships, observe keeps watching it — because shipping isn't the end. When Boots opens, it checks each live system is still working and still giving the right answer (not just that it ran), and evolves it with you.

And every so often, rethink steps back over all of it. Each stage above moves one system one step forward — which means none of them can ask whether you're building the right things at all. People assemble a machine one piece at a time and never get told what the machine is. Rethink is the step that reads everything you have, says what it adds up to, and tells you when two of your systems are really the same job, or when the piece that would tie them together doesn't exist yet. It's the one part of Boots allowed to disagree with your plan.

The stages

boots (the router) — Checks where every system stands against what actually got built, and gives you the one next step in your own words. Start here.	clarify — Turns a vague "I want AI to do X" into something real: the actual problem, what it needs to do, and a paragraph in your own words. Writes down where it stands.
scope — Cuts a clarified system to its smallest useful version, names what's out, and decides what to build (a skill, an agent, an automation, a connector, a script, or notes).	build — Makes the scoped slice in the chosen form, in the right place for your tool to find it. Produces the thing the closer then reviews, proves out, and ships.
review — Finds what's wrong, missing, or half-done — checked the right way for what it is — and writes the gaps back as concrete next steps.	verify — Proves the system works by actually running it end to end, the way that fits what it is, and writes down every step you had to do by hand.
ship — Produces the finished, usable tool, folds in each manual step verify found, and marks the system done. A system isn't done until it's shipped.	prospect — The feeder. Digs through your agent's memory, your past chats, a loose-ends list, to-do notes in your projects, and other AI tools for work worth doing, then ranks it.
track — Turns a loose, abandoned thread into a tracked system with a spot on your list, a plan for what it'll be, and a next step, so it stops rotting and enters the pipeline.	surface — The heads-up. Looks across everything you have going and says the single most useful next step — or a grounded "nothing's stuck."
rethink — Steps back over everything you've built and works out what it adds up to. Tells you when two systems are doing the same job, when nothing carries what one found to the one that needs it, and when the piece that would finish the picture doesn't exist yet. The only part of Boots that argues with your plan.	extract — After a system ships, captures what it taught, routes the lesson everywhere that fits, and asks whether it's a rule the tool itself must now obey.
retire — Proposes dropping systems, rules, or tools that have gone cold, so your list stays honest and Boots can subtract, not only add.	observe — The steward for live systems. When Boots opens, it checks each shipped system is still alive, that its latest output actually makes sense (not just that it ran), and that you're using it — then proposes concrete fixes and makes them with you. The step that keeps shipped tools from silently breaking.

What Boots is not

• Not an agent framework. Boots doesn't tell you how to build agents. It tells you how to finish the systems you build with them.
• Not just a chatbot. Yes, you talk to it — but it isn't a blank chat window you have to steer. Boots keeps track of every system you're building and drives each one to finished.
• Not a task manager. Tasks are a side effect. Boots tracks systems, what each one is, and whether it's actually shipped.
• Not a workflow builder. No drag-and-drop pipelines. The pipeline is a fixed set of steps that each do real, different work.
• Not tied to one project, or one tool. Boots works in any project and builds anything your AI tool can. What it builds follows the work.

Install — one paste

Boots runs on Claude Code and on Claude Cowork. The two install differently: Claude Code clones the repo, Cowork adds it as a plugin marketplace. Pick your tool.

Claude Code — clone and symlink

Boots is a set of Claude Code skills. There's no build step, no server, no account — you install the skills and wire them into CLAUDE.md so the agent knows they exist.

Requirements: Claude Code and Git. That's it.

Open Claude Code and paste this. Claude does the rest:

Install Boots: run git clone --depth 1 https://github.com/Fourday-AI/boots.git ~/.claude/skills/.boots && ~/.claude/skills/.boots/setup, then add the ## Boots section it prints to my CLAUDE.md.

Or do it by hand:

git clone --depth 1 https://github.com/Fourday-AI/boots.git ~/.claude/skills/.boots
~/.claude/skills/.boots/setup     # global; or `… /setup --project` for one repo

Boots clones straight into your Claude Code skills directory, so the download is most of the install. The leading dot in .boots is load-bearing: Claude Code skips dot-directories when it looks for skills, so the repo itself is never mistaken for one and the router keeps the plain name boots you type. setup then symlinks each boots* folder alongside it and prints a ## Boots block to paste into CLAUDE.md so the agent discovers the suite. Uninstall with ~/.claude/skills/.boots/setup --uninstall.

Upgrading: just say boots-upgrade — Boots pulls the new version, re-runs setup, and applies any migrations. It also notices new versions on its own and offers. By hand it's cd ~/.claude/skills/.boots && git pull && ./setup — run setup too, not git pull alone, since that's what applies migrations. Because the skills are symlinked, one upgrade updates every project at once.

Your work is kept somewhere else. ~/.boots/ holds your systems, notes and config; the clone above is only the program. Deleting or re-cloning the repo never touches them.

Claude Cowork — add the marketplace

In Cowork, Boots installs as a plugin. Open Settings → Plugins → Add marketplace → Add from a repository, and paste:

https://github.com/Fourday-AI/boots

Then install boots from the fourday marketplace. From a Claude Code terminal the same thing is two commands:

/plugin marketplace add Fourday-AI/boots
/plugin install boots@fourday

Upgrading is automatic. Boots is published straight from main, so every fix we push becomes the next version — there's no release to wait for and no version to bump. Cowork refreshes marketplaces in the background; to pull changes immediately, run /plugin marketplace update fourday. (This is why you won't find a boots-upgrade skill here: on Cowork, updating is the marketplace's job, not yours.)

One prerequisite, and it matters. A Cowork session runs in a sandbox that is wiped when the session ends. Boots' whole promise is that your board is still there next week, so it needs somewhere durable to keep it — connect a folder before your first run, and Boots will put its home there and tell you which folder it chose. Without one, Boots still works for a single session, but nothing survives it. If you're not sure, just say boots and it will walk you through it.

Try it in five minutes

1. Install (above).
2. Say boots, then describe one fuzzy "I want AI to do X" you keep meaning to build.
3. Just talk — react to what it asks, say yes when it offers to build. It drives.
4. Keep going until it says the system is shipped.
5. Stop there. You'll know if this is for you.

FAQ

What is a "system" in Boots? Anything your AI tool can build — a skill, an agent, an automation, a connector to another app, a script, or a piece of reference it reads — or a small mix of these. Boots picks which one from what the job needs.

The exact menu depends on the tool you're in, and Boots reads the right one rather than assuming:

• Claude Code: skills, subagents, slash commands, hooks, MCP servers, Agent SDK apps, scripts, and durable context.
• Claude Cowork: skills, scheduled tasks (a job that runs on a clock, unattended), connectors, deliverables (a real .docx/.xlsx/.pptx you open), artifacts (a page that stays in your sidebar), plugins, subagents, workflows, and durable context.

That difference is not cosmetic. If what you want is "every Monday morning, without me remembering", that's a scheduled task — a shape a terminal doesn't have, and the one Boots will steer you to on Cowork.

Where does Boots keep track of things? Boots keeps plain notes files as it works — one per system, plus a short summary of each chat. They live in one fixed place, deliberately not inside whatever project you happen to be working in. A system is your work, not your repo's, so you can pick it up from any directory, and it never ends up committed to a codebase you push. Nothing depends on you remembering. You don't need to read the files either — ask Boots about a system and it reads the record back to you.

On Claude Code that place is ~/.boots/ on your own machine. On Cowork the session itself is a sandbox that gets wiped, so Boots keeps its home in a connected folder instead — it works out where that is on first run and tells you which folder it chose, rather than quietly writing somewhere that's about to disappear.

How is this different from a task manager or a builder toolkit? Toolkits help you start; task managers track titles. Boots follows a tool through its whole life and, crucially, finishes it — reviews it, proves it works, ships it — so half-built tools stop piling up looking done.

Do I have to use every stage? No. Run boots and it routes you to the stage a system actually needs. The anytime skills (prospect, track, surface, observe, extract, retire) run whenever you like.

Roadmap

• ✅ Full build-and-close pipeline (clarify → scope → build → review → verify → ship)
• ✅ Never lose your place — every system remembers where you actually are
• ✅ Self-healing — Boots catches a chat that did the work but forgot to write it down
• ✅ Finds work — digs through your chats, notes, and to-dos for what's worth building
• ✅ Learns — lessons from finished tools become rules the next one follows
• ✅ Watches live systems — checks a shipped tool still works and still gives the right answer, and evolves it with you
• ✅ Builds any form — skill, agent, automation, connector, app, script, or notes
• 🟢 Packaged as an installable plugin, published from a marketplace in this repo (Cowork today; Claude Code still installs by clone)
• 🟡 Support for other AI tools beyond Claude Code — Claude Cowork is live; more to come
• ⚪ Finds work in more places (more sources it can dig through)

Privacy & telemetry

Off by default. Nothing leaves your machine unless you turn it on.

Everything Boots writes about your work — the systems, the session notes, the map of what you're building — is plain files in ~/.boots/ on your own machine. Boots never sends any of it anywhere.

Separately, there is an optional, opt-in telemetry channel that helps us see whether Boots actually gets people to finished — where systems stall, which stage loses people. You're asked once, plainly, and you can say no and never hear about it again. There are three settings:

setting	what leaves your machine
off (default)	nothing.
anonymous	the records below, with no device id at all
community	the same, plus a random per-install id, so one install's path through the pipeline can be followed end to end

The records are: a stage transition (scope → build), whether it advanced, stalled or was abandoned, the system's form and platform (skill, claude-code), your OS name, and which skill ran, for how long, and whether it succeeded.

(Boots keeps a local record of your own pipeline regardless of this setting — that's what lets it tell you where things are stuck. The setting governs uploading, and only uploading.)

The system's name is hashed before it leaves — salted with a random value generated on your machine, so the same name on two installs produces two unrelated hashes, and no hash can be reversed. The per-install id is random, not derived from your machine. Your repo's name is recorded locally so Boots can find your work across directories, and is stripped before upload.

What is never sent: the content of any system, your notes, prompts, code, file paths, repo names, or anything you typed. Only the shape of the funnel.

The simplest way to change it is to just ask — say "boots, turn telemetry off" and it runs the right command for wherever it's installed. By hand, on Claude Code:

~/.claude/skills/boots/bin/boots-config get telemetry   # off | anonymous | community
~/.claude/skills/boots/bin/boots-config set telemetry off

On Cowork the same script lives inside the installed plugin rather than at a fixed path, so ask Boots rather than guessing where it landed.

The backend is in supabase/ — schema, edge functions and all — so you can read exactly what is accepted and stored rather than taking our word for it. The client side is one readable shell script: boots-telemetry-sync.

On Claude Code, Boots also checks for updates by asking your git remote whether the clone is behind. That's a plain git call to wherever you cloned from, and it's off with boots-config set update_check false. On Cowork there is no clone — updates come from the marketplace, so nothing here phones anywhere on Boots' behalf.

Contributing

Contributions are welcome. See CONTRIBUTING.md — the one rule worth knowing up front is that the skills are generated from .tmpl templates, so you edit the template and regenerate, never the SKILL.md.

License

MIT © 2026 Fourday AI

---

_{Open source under MIT. Built for people who start more AI systems than they finish.}