agentleFS
exm7777exm7777/co-founder/.agents/skills/sprint/SKILL.md

sprint

Skill0 starsChanged 3 months agoMITView on GitHub

The daily driver. Open the session knowing exactly where the business stands and what the ONE next move is, then execute one roadmap step to done. Run when the user says "where are we", "what should I do today", "let's work", "start the day", "continue on...", or opens a session cold with no specific ask. Orientation is this skill's job, never the founder's memory.

29 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use ecosystem-reference, fractal-delegation and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • naman10parikhSkill

    ecosystem-reference

    Quick-access directory of Claude Code ecosystem repos, skills, plugins, MCPs, and patterns. Use when improving the harness.

    Also in 5 projects that use this

  • naman10parikhSkill

    fractal-delegation

    Also in 5 projects that use this

  • roronoazoroshao369Skill

    memory-compression

    Also in 5 projects that use this

  • KirchliveSkill

    skill-routing

    Decides which of the installed skills a task needs and loads them before the work starts. This skill should be used at the beginning of any multi-step task — build, fix, refactor, migrate, review, plan, release, research, write, design, video — and again at every phase change, after context compaction, and when work moves into a different part of the codebase. Use it for requests like "let's build X", "fix this bug", "refactor Y", "plan the migration", "review this", and also when the user asks which skill applies, why a skill did not fire, or asks to check what is available.

    Also in 5 projects that use this

  • sublimotionSkill

    agent-runtime

    Launch and manage detached agent runs on EKS via the agent-runner CLI. Use when the user says "launch an agent run", "agent runtime", "agent-runner", "run this spec on the cluster", "check run status", "agent run logs", or "stop a run". Do NOT use for writing the agent-runner code itself (edit the sibling ../agent-runner repo), Terraform of the foundation (use terraform-automation), or GPU serving deployments (use infra-deployer).

    Also in 5 projects that use this

  • GoZippySkill

    repo-scout

    Also in 5 projects that use this

  • +5 more from naman10parikh

The file

We split this skill into the rules it gives an agent

5 rules. 0 are common, 1 is distinctive, and 4 are very specific to this project.

  • 0

    Common

    Most of the 26 edited versions we read keep these.

  • 1

    Distinctive

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Before any step, read references/CONVENTIONS-core.md.

    line 29
  2. Very specific:

    Run the shared contract's Universal preflight.

    line 35
  3. Very specific:

    No active initiative is a legitimate first-use state.

    line 40
  4. Distinctive:

    Ask before you assert: never present a quantity, duration, sample size, date, or causal motive in prose before asking the founder for it or …

    line 113
  5. Very specific:

    Run scripts/graph-audit on every touched durable file.

    line 137

“Common” is measured: kept by at least 6 in 10 of the 26 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

sprint: one step, finished, every session

Founders don't fail from missing strategy; they fail from open loops. Sprint closes them: every session starts oriented, works exactly one step of the roadmap to done, and ends with the state saved so tomorrow starts oriented too.

  session opens
       |
  [ standup ]   baton + active initiative -> 5 lines + ONE next move
       |
  [ gate ]      state must be planned/executing, or it routes to plan
       |
  [ one step ]  session-sized, finished completely, verified
       |
  [ close ]     box checked, fog graduated, baton rewritten

Before any step, read references/CONVENTIONS-core.md. This resolves from the installed skill directory to the plugin's shared contract, independent of the founder's working folder. Its state, receipts, and queue item rules govern this workflow.

Step 0: Standup

Run the shared contract's Universal preflight. A Fresh, Partial, or Wrong-folder result stops and runs the co-founder-setup skill before anything else (re-sync for Partial), without inventing a baton or initiative. On Ready, read, in order: the charter, baton.md at the vault root (the last session's closing note), the active initiatives in wiki/initiatives/ (states planned or executing), and any waiting "Needs your call" sections.

No active initiative is a legitimate first-use state. Say "Nothing is active" with the file search that proved it. If wiki/business/vision.md is missing, propose exactly one focus: run vision. If vision exists, read its quarter goal and propose exactly one focus: run plan on that goal. Stop before the execution gate; there is no roadmap step to execute yet.

More than one initiative active: the tiebreaker is deterministic. Take the one baton.md names if it is still active; otherwise prefer executing over planned, then the most recent Log entry. Still tied: one question, with a recommended focus and the tie named.

Then report in AT MOST five lines: where things stand, what happened last session, what is waiting on the founder, and exactly ONE suggested focus. One focus, never a list; a menu is a decision pushed back onto the person who hired you to carry it. Every line cites where it came from (file or log row); a fact you cannot source is reported as "not on record", never improvised.

Accountability, factual and unheated: the last baton named a next move and any committed dates. Compare against what actually happened. A slip gets stated plainly ("the pricing page was the move, it didn't happen") and one question: what changed? The answer often belongs in the roadmap or the vault; route it there.

Done when: the founder knows the state, the slippage if any, and the ONE proposed move, or the zero-active route has handed them to vision or plan.

Step 1: The gate

The chosen work's initiative must be exactly planned or executing. Every other state refuses execution per the refusal shape in the shared contract (name the missing stage, ask the first missing question): idea and survived route to plan (BIG ideas that have not faced the gauntlet go there first), reviewed and banked are closed arcs whose renewed work needs a new idea with reopens: pointing to the closed file, and an unknown or malformed state stops for repair, never gets guessed around. The founder's enthusiasm today does not outrank the gate; the gate is what their enthusiasm hired.

A founder ask that is NOT on the active roadmap gets one explicit line before any work. The ask matches a "Not yet decided" item whose answer is now visible: ask the one confirmation it needs, then move it into Next steps as a session-sized checkbox. It matches nothing: it is new scope and routes through plan first. Silent scope additions are how roadmaps become fiction.

Apply the shared parameter gate to any new time block, due date, quantity, or completion threshold. The roadmap can supply a recorded value; otherwise ask one question or leave an unverified candidate. Sprint never invents a two-hour block to make a useful habit sound concrete.

Done when: the work about to start maps to one legitimate roadmap step.

Step 2: Execute the one step

Starting the first-ever step on a planned initiative: set state: executing NOW, before the work, with updated: bumped. The state says work has begun; an interrupted session must not leave the file claiming otherwise.

Work the step with the founder to DONE, where done is the checkbox's own text, visibly completed and verified in the session. The discipline:

  • One step per session. The urge to start a second one goes into the roadmap, never into the session.
  • Operational next moves cite the initiative or log that makes them next. Facts get the source appropriate to the claim (vault for this business, research for the outside world). Consequential recommendations use both legs and park if either is missing.
  • Founder-only calls that would block progress go to "Needs your call" in the initiative file, and the work continues around them where it can.
  • A step that turns out bigger than one session gets split honestly: finish the true session-sized core now, write the remainder as new steps. Say so out loud.

For a step containing "approve" or "publish," re-read the canonical content file before checking the box. Approval requires content_state: approved|published plus a checked approval_receipt; publication requires content_state: published, published_at, and a checked publication_receipt. These are T1 consent surfaces (shared contract, Immutable consent receipts): the receipt must cite the founder's exact words in immutable raw/inbox/. A wording edit or founder-reported publication without those fields leaves the step unchecked. Graph-audit enforces this relationship after the write.

Ask before you assert: never present a quantity, duration, sample size, date, or causal motive in prose before asking the founder for it or citing a receipt for it.

Any business fact written during execution passes the shared durable claim admission gate at write time. Reopen the cited source and quote the supporting line, recompute from named inputs, or label the statement Founder-stated: unverified; a baton summary cannot verify its own claim.

Done when: the step's own completion text is true and shown to be true.

Step 3: Close the session

In this order:

  1. Recheck the step's literal completion condition and its canonical evidence. Check the box only when both are true; then add the dated line to the initiative's Log section.
  2. Confirm the frontmatter reads state: executing (step 2 set it when work began). Move the initiative link to the executing hub bucket and update the index state/step summary; this is one linked-state transaction, not steward work deferred to later.
  3. Graduate any "Not yet decided" entries the finished step made answerable into concrete next steps. The roadmap's frontier just moved; chart the newly visible ground.
  4. Append ## [date] sprint | <step title> to log.md.
  5. Rewrite baton.md at the vault root: what happened this session, where the initiative stands, the ONE next move, open threads, anything waiting on the founder. Reference vault files by path, never duplicate their content.
  6. Run scripts/graph-audit on every touched durable file.
  7. Fix every violation and rerun it. Check the roadmap box, close the log/baton transaction, and declare the step done only after it exits zero.
  8. Close with two lines to the founder: what got finished, and what tomorrow's move is.

Done when: a fresh session tomorrow could run its standup from the baton alone and lose nothing.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.