Agentic WoW
A way of working for agent-led delivery.
Feature-Driven Development, extended with a compounding memory loop and a session journal. The framework we build our own products on. It keeps human and AI agents moving in the same direction, and commit-time guardrails enforce the structure. Now available for your team to adopt.
What you get
For your teamCoherent delivery
Work stays right-sized. Nothing sprawls. Nothing gets lost between sessions.
Release rhythm
Small features close, often. The team builds momentum instead of debt.
Compounding memory
Every cycle ends smarter than it started. Your project remembers what it learned.
Humans and agents, same loop
AI teammates plug in without breaking the shape of the work.
Works with the tools your team already uses
Claude Code
Cursor
GitHub Copilot
VS Code
GitHubGitHub Actions
MCP servers
GitThe loop
Feature → Plan → Build → Memory.
Four steps that compound. Each cycle ends with the project knowing more than it did at the start, so the next cycle starts further ahead.
Feature
A business requirement, expressed as user-observable behaviour. Captured as user journey, rules, and validation. No implementation detail.
Plan
One per feature. Tasks that are sized and statused, plus the decisions and open questions behind them.
Build
The code itself, with tests. Decisions are captured in the plan as the work happens.
Memory
Atomic notes (rules, pitfalls, conventions) that persist across sessions and compound over time.
Artifacts
Three artefacts that outlive any session.
The loop produces code, but it also leaves a durable trail. Each artefact has one job and one home in the repo, so anyone, human or agent, can pick up where the last one left off.
Feature
features/<epic>.md + feature-index.mdA business requirement, expressed as user-observable behaviour with no implementation. The spec lives in the epic file; its lifecycle state lives in the index. One row per shippable change.
Plan
plans/<CODE>-plan.mdOne per feature, persisting for the life of the project. Sized, statused tasks plus the decisions and open questions behind them. Plans grow as work lands; nothing is deleted.
Memory
memories/<type>_<topic>.mdDurable, cross-feature notes covering rules, pitfalls, and conventions. Emergent, not prescribed: extracted mid-build when something is worth keeping, indexed for the next cycle.
Sizing
L and XL are hard stops.
Every epic, feature, and plan task carries a t-shirt size. L and XL are hard stops, and must be split before work starts. The size is a forcing function: if you can’t size it, you don’t yet understand it.
- XSTrivial, single-file edit. Under an hour.Go
- SSmall, a few files. Half a day to a day.Go
- MTypical, one to two days, a single surface.Go
- LMulti-day or cross-cutting. Must split.Split
- XLToo big. Split before starting.Split
Tooling
Enforced by a framework and fixed process.
The Agentic way-of-working ships as a family of skills and tools bound by a framework and a process flow, for a consistent way of working and quality artefacts.
Set up & import
/wow-initBootstraps the layout and activates the commit-time guardrails. Safe to re-run to pick up upstream updates without touching your content.
/wow-discover-featuresReverse-engineers an existing codebase into epic files, feature-index rows, and plans, proposing splits for anything oversized.
Shape the work
/wow-refine-featureRight-sizes epics and features, enforces the user journey · rules · validation shape, lints for implementation leak, and keeps the index in sync.
/wow-refine-planDrafts a plan from a feature, right-sizes tasks (L and XL must split), and enforces the tasks · decisions · open-questions shape.
/wow-playwright-testsMaps tests to validation criteria, scaffolds the gaps, enforces Page Object Model, and keeps E2E vs unit on the right side of the pyramid.
Run a session
/wow-startLoads full session context (methodology, memories, and handover files), then prints a brief so work starts oriented.
/wow-resumeRe-hydrates the same context mid-session after a compaction. Same file set, same brief as starting fresh.
/wow-wrap-upUpdates the session journal for a cold-context resume and surfaces the memory candidates worth keeping.
/wow-show-dashboardRegenerates the static feature/plan/epic dashboard from current state and opens it in the browser.
Guardrails
Enforcement, at commit time.
The way of working installs hooks that fire on every commit and block on failure, so the structure holds itself together on every run, by anyone, human or agent.
Before the agent commits
A pre-tool hook checks every commit an AI agent attempts, blocking broken internal links (paths or anchors) before git ever runs.
Before any commit lands
A native git pre-commit hook runs the same checks for every commit from any tool (CLI, IDE, or agent) so a human typing git commit is held to the same bar.
Before context compresses
A pre-compact hook refreshes the session handover files first, so nothing is lost when the context window is squeezed mid-session.
How to get it
It lands in your repository, with the work.
Agentic WoW ships as a repository template. Your team starts from it, keeps it under version control alongside the code, and shapes it to how you deliver. Access is granted per team so we can help you land it properly.
Ask us for access
Tell us what your team builds and how you work today. We grant access to the template repository and walk you through what lands in it.
Start from the template
Create your repository from the template. The way of working, the artefact structure, the runbooks, and the agent skills arrive with it.
Sync the skills
Run the sync script to install the agent skills into your coding assistant, then shape the templates around your own delivery.
Research first
Every method has a source.
We're a lab. We use published datasets and methods, pin the exact versions, and publish how we tested.
- [01] ACL · 2023
Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models
Wang et al. (2023)
Backs: Plan stage. Explicit plan-then-execute, not single-pass generation.
- [02] NeurIPS · 2022
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
Wei et al. (2022)
Backs: Plan stage. The intermediate-reasoning discipline that planning artefacts make durable.
- [03] NeurIPS · 2023
Reflexion: Language Agents with Verbal Reinforcement Learning
Shinn et al. (2023)
Backs: Memory stage. Verbal self-feedback that compounds across iterations.
- [04] NeurIPS · 2023
Self-Refine: Iterative Refinement with Self-Feedback
Madaan et al. (2023)
Backs: Build stage. Iterative self-feedback before a commit, codified by the framework's guardrails.
- [05] TMLR · 2024
Voyager: An Open-Ended Embodied Agent with Large Language Models
Wang et al. (2024)
Backs: Skills system. Reusable, parameterised skill library that grows with the agent.
- [06] UIST · 2023
Generative Agents: Interactive Simulacra of Human Behavior
Park et al. (2023)
Backs: Memory stage. Observation to reflection captured in the session journal.
Citations include preprints alongside peer-reviewed work. We interpret current LLM-agent research alongside established cognitive science, databases, and information retrieval.