agilebydesign

Set and read the agent engagement root (skill-config.json → workspace.active_skill_workspace). Run scripts from this folder; they resolve the agent root automatically.

Track multi-step work with markdown checkboxes (- [ ] / - [x]) for any skill or agent—pipeline phases, per-phase steps, or ad-hoc lists—under the engagement workspace, without editing normative skill sources.

Scan a folder of deployed skills and regenerate a one-pager Markdown inventory and an HTML catalogue. Each entry shows the challenge the skill addresses and the solution it provides, hyperlinked to the skill directory. Re-run on command to keep the catalogue current.

Render and synchronize story-map DrawIO diagrams (outline, exploration with acceptance criteria, prioritization increments) from story-graph.json. Uses **story-graph-ops** for validated JSON load/save and **story_graph_ops** (StoryMap, nodes, domain) for the story tree that DrawIO rendering expects. Use when producing or diffing story-map.drawio files, or when wiring CI/scripts for diagram refresh and update reports.

Teaches exploration-phase acceptance criteria for story-graph.json: WHEN/THEN/AND/BUT, behavioral language, per-story domain terms, atomic AC, actor alternation, channel-specific detail, and verb–noun naming for story elements. Ships Markdown rules and Python scanners under this skill root for **execute_rules** (mechanical checks alongside human review). When building AC from sources, output **all** template artifacts in `templates/` (currently `acceptance-criteria.md` and `acceptance-criteria.txt`) with the same coverage. Use when writing or reviewing acceptance criteria, exploration behavior, WHEN/THEN quality, or story-graph.json AC arrays.

Create, read, update, and delete story-graph.json (whole file or parts—epics, sub-epics, stories, AC, scenarios) as a **standalone artifact**—no host app required. **Agents must complete the ops loop**: use this skill’s CLI or Python modules under scripts/, then validate the file—do not stop after hand-writing JSON from memory or from reading other repositories for “schema hints.” Prefer the story-graph CLI; use story_map and related modules for richer edits. Complements ABD practice skills—ops skill owns the serialized graph lifecycle on disk.

Bundle rules into SKILL.md, run scanners, quality steps (rules before work), and the correction process after mistakes — commands first, details after.

Deploy a skill from agilebydesign-skills into Cursor's user skills folder using a Windows directory junction (no duplicate copy). Run scripts/Deploy-SkillToCursor.ps1 with the skill folder name. Use when you want the global Cursor skills path to point at the repo canonical skill.

**Produce** thin-sliced delivery increments: vertical MVIs, spine vs optional paths, quality trade-offs, marketable increment names, and early risk validation. From a story map, **write** all template artifacts in `templates/` (`thin-slicing.md` and `thin-slicing.txt`) with identical increment and story coverage. Use when planning releases, MVIs, backlog order, or thin/vertical slices after mapping.

Produce specification-by-example scenarios: concrete Given/When/Then steps with real domain values, bold concept names, italic values. Two templates: plain scenarios (inline values, default) and outline (same steps, multiple data rows). Use when writing BDD scenarios, refining AC into specs, or making story behavior concrete.

Scan agilebydesign-skills (`skills/` and `agents/`), maintain each package’s root `README.md` for catalogue copy (overview + ASCII), then regenerate `catalog/` HTML and `outline.md` from those files plus a generated file tree.

Respond to client proposals (RFP, Q&A, requirements) by converting materials to memory, creating a response strategy, and answering questions iteratively. Depends on abd-context-to-memory for RAG. Use when responding to proposals, creating response plans, answering RFP questions, or iterating on proposal strategy.

**Object-Oriented Analysis and Design (OOAD) from raw material.** Use this skill whenever you're working with specifications, game manuals, policy docs, messy code, or rule books that need to be modeled as object-oriented domain models. Agile by Design methodology: Steps 0–2 (Domain Scan, Extraction, Refinement) with built-in Draw.io diagram generation via scripts/drawio_cli.py. ALWAYS use this skill when a user provides domain material and asks you to extract domain concepts, build class diagrams, identify responsibilities, or create object models. Create domain-scan-model.md and domain-scan-model.drawio files in the project workspace.

Experimental **file-based war room** for handoffs between `abd-delivery-lead` and `abd-team-member`: `delivery-war-room/` under the engagement workspace with `INSTRUCTIONS.md`, `manifest.md`, and `slot-NN-start.md` / `slot-NN-finished.md`. **Not wired into the delivery-lead or team-member agents** until re-integrated from first principles. Use this skill only when you explicitly opt in to the war-room pattern and copy the templates below into the engagement.

Build and revise agile delivery plans: context assessment, risk types, strategies (scan strategies/ for matching When to use), runs (stages, scope, checkpoints, rationale), and example plans. Planning only — not for producing story artifacts, tests, or code (those come from downstream practice work).

Generate meaningful commit messages from scope and changed files. No story_graph — scope from conversation, changed files, and persisted state. Use when user types /commit or requests a commit.

Write production code that implements story behavior using domain language, clean functions, explicit dependencies, and observable design. This skill covers the full quality bar for implementation code: single-responsibility functions and classes, intention-revealing names, explicit constructor injection, guard-clause control flow, domain exceptions, encapsulation, and DRY structure. Use it when writing any production module from scratch, reviewing code for quality, driving the GREEN phase of a TDD cycle, or refactoring to clean up debt. Produces Python or JavaScript/ES module output from templates and validates against embedded scanner-backed rules.

Write tests first, then drive code to pass them. Creates executable test files in the target language and framework from any behavioral context — spec-by-example scenarios (ideal), acceptance criteria, stories, notes, or rough descriptions. Orchestrator pattern: Given-When-Then test methods call helper functions; one class (or equivalent) per behavior, one test per scenario. Covers TDD cycle (RED-GREEN-REFACTOR), domain language, API design through failing tests, and production code rules. Use when writing acceptance tests, turning behavioral context into test code, or driving implementation with tests.

Teaches Patton-style story mapping: epics, sub-epics, stories, verb–noun naming, and actors via story_type. When building a map from sources, outputs **all** template artifacts in `templates/` (currently `story-map.md` and `story-map.txt`) with the same tree — not one or the other. Use when structuring product discovery, decomposing user journeys, identifying epics and flows, story mapping, organizing requirements into a hierarchical map, or when the user mentions story maps, epics, sub-epics, or Jeff Patton–style backlog structure.