cognitives/skills/workflow/sprint-forge/SKILL.md
Adaptive sprint workflow: deep analysis, evolving roadmap, one-at-a-time sprints, formal debt tracking, and re-entry prompts for context persistence. Trigger: When the user wants to analyze a project, create a roadmap, generate/execute sprints iteratively, or check project status and technical debt.
npx skillsauth add synapsync/synapse_registry sprint-forgeInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
This skill uses a modular assets architecture. Detailed workflows, helpers, and templates are in the assets/ directory:
See assets/README.md for full directory documentation.
Sprint Forge is an adaptive sprint workflow skill designed for iterative project execution. Unlike rigid planners that pre-generate all sprints upfront, Sprint Forge:
This skill works for any project type, language, or framework.
RULE 1 — SPRINT-BY-SPRINT
Sprints are generated ONE AT A TIME. Never pre-generate all sprints. Each sprint is informed by the previous sprint's retro, recommendations, and accumulated debt. This ensures the plan adapts to reality.
RULE 2 — SUGGESTED PHASES, NOT RIGID
The roadmap defines suggested phases per sprint. During execution, emergent phases MUST be added when new findings surface. Phases are guidelines, not constraints.
RULE 3 — RETRO IS FORMAL INPUT
The retrospective and recommendations from Sprint N-1 are formal input for Sprint N. Every recommendation must either become a task in the next sprint or have its deferral justified in the Disposition table.
RULE 4 — DEBT NEVER DISAPPEARS
The Accumulated Technical Debt table is inherited sprint to sprint. An item is only closed when explicitly resolved. Items are never deleted — only their status changes.
RULE 5 — ADAPTIVE
The roadmap is a living document. If execution reveals that a planned sprint no longer makes sense, the roadmap is updated. The plan serves execution, not the reverse.
RULE 6 — LANGUAGE-AGNOSTIC
This skill works for any language, framework, or project type. It does not assume Flutter, React, Dart, or any specific technology. The analysis determines the structure.
RULE 7 — CONTEXT PERSISTENCE
After INIT and after each executed sprint, re-entry prompts are updated. These prompts allow any agent in any session to recover full project context and continue seamlessly.
| Capability | INIT | SPRINT | STATUS | |-----------|:----:|:------:|:------:| | Analyze codebase/project | Yes | No | No | | Create vault structure | Yes | No | No | | Generate roadmap | Yes | No | No | | Generate/update re-entry prompts | Yes | Yes | No | | Generate sprint | No | Yes | No | | Execute sprint tasks | No | Yes | No | | Write/modify code | No | Yes | No | | Read vault/sprints | Yes | Yes | Yes | | Update accumulated debt | No | Yes | No | | Report progress | No | No | Yes |
{output_sprint_forge_dir} is the directory where sprint-forge stores all project documents. Resolve it once at the start of any mode:
/Users/.../ROADMAP.md), extract {output_sprint_forge_dir} from those paths. It's already there.README.md and RE-ENTRY-PROMPTS.md. These are the only sources of truth..agents/sprint-forge/ in {cwd}, or ask the user directly.No AGENTS.md. No branded blocks. The re-entry prompts and README carry the path across sessions.
All generated markdown documents include YAML frontmatter following the Obsidian markdown standard. The agents field tracks the AI model that generated or modified the document. Resolve {agent_model} from the model ID powering the current session (e.g., "claude-opus-4-6", "gpt-4o", "codex", "grok"). When modifying an existing document, append the current model to the agents array if not already present.
| Mode | EN Signals | ES Signals | What It Does | |------|-----------|-----------|-------------| | INIT | "analyze", "audit", "start project", "create roadmap" | "analiza", "audita", "inicia proyecto", "crea roadmap" | Analyzes the project, generates findings, creates roadmap, scaffolds vault, generates re-entry prompts | | SPRINT | "generate sprint", "next sprint", "execute sprint" | "genera sprint", "siguiente sprint", "ejecuta sprint" | Generates the next sprint from roadmap + previous sprint + debt, optionally executes it | | STATUS | "project status", "progress", "technical debt" | "estado del proyecto", "progreso", "deuda técnica" | Reports completed sprints, accumulated debt, metrics, next sprint preview |
Disambiguation: If the user's intent is unclear, ask:
"Do you want me to analyze the project (INIT), generate/execute the next sprint (SPRINT), or check project status (STATUS)?"
After detecting the mode, read ONLY the assets listed for that mode. Do NOT read assets for other modes — they waste context tokens.
| Mode | Read These Assets | Do NOT Read |
|------|-------------------|-------------|
| INIT | INIT.md, analysis-guide.md, reentry-generator.md | SPRINT.md, STATUS.md, sprint-generator.md, debt-tracker.md |
| SPRINT | SPRINT.md, sprint-generator.md, debt-tracker.md, reentry-generator.md | INIT.md, STATUS.md, analysis-guide.md |
| STATUS | STATUS.md, debt-tracker.md | INIT.md, SPRINT.md, analysis-guide.md, sprint-generator.md, reentry-generator.md, all templates |
On-demand assets: Templates are loaded as each workflow step references them, not upfront.
Use when starting a new project workflow:
Analyze this project and create a roadmap for the refactoring work.
This will: explore the codebase, generate findings, create an adaptive roadmap, scaffold the output directory, and generate re-entry prompts.
Full workflow: See assets/modes/INIT.md
Use when ready to work on the next sprint:
Generate the next sprint.
Or to generate and immediately execute:
Generate and execute the next sprint.
This will: read the roadmap and previous sprint, build the disposition table, generate phases, and optionally execute task by task.
Full workflow: See assets/modes/SPRINT.md
Use to check project progress:
Show me the project status and technical debt.
This will: read all sprints, calculate metrics, display progress and accumulated debt.
Full workflow: See assets/modes/STATUS.md
| Skill | Integration |
|-------|------------|
| code-analyzer | INIT: Can be used as a preliminary step. The code-analyzer reports feed into Sprint Forge findings, providing structured technical input for the roadmap. |
development
Rigorous dead code audit for any module, folder, or file in any programming language. Detects orphan files never imported anywhere, classes/functions/ methods declared but never called, constructor parameters received but never consumed, unused imports/requires, private fields with no references, and commented-out code blocks. Use this skill whenever the user asks to: review unused code, clean up a feature after a refactor, find dead code, detect orphan files or classes, audit what can be deleted, find what's left over after a big change, or any variation of "what's not being used / what can I remove". Also triggers when the user says they made large changes and wants to know what became obsolete. IMPORTANT: This skill only reports — it never deletes anything. At the end it always offers to generate a removal plan with /plan.
tools
Registers new cognitives (skills, agents, prompts, workflows, tools) into the SynapSync Registry with proper structure, manifest, and registry index. Trigger: When the user says "GUARDA", "REGISTRA", "AGREGA" followed by a cognitive type and name, or asks to save/register/add a cognitive to the registry.
documentation
Session memory for AI agents — load context at the start, save sessions at the end, evolve knowledge across sessions. Like a professional's notebook: open before work, write a summary when done, persist between sessions. Trigger: When starting a session and need to recover context, or ending a session and want to save what happened.
documentation
Unified planning and execution skill for any software scenario. PLAN mode produces structured documentation; EXECUTE mode implements sprints from plan output. Trigger: When planning or executing any software work that requires structured analysis and actionable task plans.