Session Flow
matshoppenbrouwers/session-flow
Ciclo de vida de desenvolvimento completo com orquestração dependente e brainstorming colaborativo
Ver no GitHubOrquestrador de ciclo de vida completo de desenvolvimento para Claude Code, integrando 13 skills e 4 agentes que cobrem pesquisa, design, planejamento, delegação, verificação e release. Implementa paralelização dependente, backlog persistente e auditoria de segurança com gates de decisão em cada etapa crítica.
Instalação
npx convez-ai matshoppenbrouwers/session-flow1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Estruturar fluxo end-to-end de desenvolvimento em projetos complexos
- Paralelizar tasks mantendo dependências e sequência correta
- Manter backlog vivo com triagem, grooming e execução automatizados
- Auditar segurança e liability antes de release
Veredito

Session Flow é uma solução robusta e bem estruturada para equipes que precisam de orquestração rigorosa do desenvolvimento. A abordagem de 13 skills compostos oferece flexibilidade — entrar em qualquer ponto da cadeia — mas exige disciplina para manter. Ideal para projetos com muitas dependências e requisitos de auditoria; pode ser sobrecarga para sprints rápidas.
README
A tradução para o português deste README ainda está na fila.
session-flow — Claude Code plugin for session workflow orchestration
session-flow is a Claude Code plugin that orchestrates the full software development lifecycle — a chain of 13 skills and 4 agents covering research, design, task planning, agent delegation, post-implementation, evidence-based verification, and release. It adds dependency-aware parallelization, a standing task backlog, collaborative brainstorming, and a security & liability audit, with user gates at every critical decision.
Install in Claude Code:
/plugin marketplace add matshoppenbrouwers/session-flowthen/plugin install session-flow@session-flow
The Chain
session-init ──> gatekeeper ──> research-design ──> task-planning ──> delegation ──> post-impl ──> verify ──> release
(one-time) (triage (collaborative (break into (dispatch (simplify, (evidence- (version bump,
intake) brainstorming) session tasks) agents) review, based proof) package, verify)
audit, test) (optional,
│ heavy)
update-architecture
sequence layer: gatekeeper / add-task / task-planning ──> SEQUENCE.md ──> groom ──> next
Each skill produces artifacts that feed into the next. Start anywhere in the chain based on what you already have. The sequence layer runs alongside the chain: a standing backlog (todo/SEQUENCE.md) that gatekeeper/add-task fill, groom prepares, and next works through.
Install
Step 1 — Register the marketplace:
/plugin marketplace add matshoppenbrouwers/session-flow
Step 2 — Install the plugin:
/plugin install session-flow@session-flow
Works on macOS, Linux, and Windows.
Getting Started
- Install session-flow (see above)
- Run
/session-initin Claude Code to set up your project's documentation structure - Start building:
/session-research-designfor new features,/session-task-planningif you already have a plan
Skills
| Skill | Trigger | Produces |
|---|---|---|
| session-init | /session-init | Directory structure, SEQUENCE.md, .session-flow.json config |
| session-gatekeeper | /session-gatekeeper | Triaged issues routed to the sequence or to research-design |
| session-research-design | /session-research-design | Research report + implementation plan |
| session-task-planning | /session-task-planning | Task file with dependency tags [seq], [parallel-after:X] |
| session-add-task | /session-add-task | Sequence entry + per-task breakdown file |
| session-groom | /session-groom | Researched breakdowns attached to raw backlog entries |
| session-next | /session-next | The next backlog task implemented and marked done |
| session-delegation | /session-delegation | Completed implementations via parallel agent dispatch |
| session-post-implementation | /session-post-implementation | Refined code, security audit, test plan, updated docs |
| session-verify | /session-verify | Evidence-based verification artifact proving implementation matches design spec |
| session-release | /session-release | Versioned artifacts, updated satellite content |
| update-architecture | /update-architecture | Surgical architecture doc updates |
| security-liability-audit | /security-liability-audit | Technical security + legal liability findings |
Entry Points
You don't have to start at step 1:
| You have... | Start with |
|---|---|
| Incoming issues or ideas to triage | /session-gatekeeper — route them to the backlog or a design session |
| A running backlog | /session-next — implement the next ready task |
| A vague idea | /session-research-design — collaborative brainstorming refines it |
| A plan or spec | /session-task-planning — break it into session-sized tasks |
| A task list | /session-delegation — dispatch agents to execute |
| Working code that needs polish | /session-post-implementation — simplify, review, audit, test |
| A completed feature/plan that needs proof it works | /session-verify — falsification-based evidence artifact |
| Tested code ready to ship | /session-release — bump version, package, verify |
| A specific security concern | /security-liability-audit — standalone security + liability scan |
The Chain in Practice
A typical session might look like:
You: /session-research-design
Claude: "What problem are we solving?" → one question at a time →
proposes 3 approaches → presents design section by section →
writes research report + implementation plan
You: /session-task-planning
Claude: Reads the plan → breaks into 8 tasks with dependency tags →
identifies 3 parallel opportunities → saves to todo/
You: /session-delegation
Claude: Parses dependency graph → dispatches 2 agents in parallel →
marks tasks [x] as they complete → reports progress
You: /session-post-implementation
Claude: Simplifies code → reviews for bugs → sanitizes dead code →
runs full test suite → updates architecture docs →
generates manual test plan
You: /session-verify (optional — for plans/features with a design doc)
Claude: Reads design + plan → writes falsifiable hypotheses →
runs structural audit → executes full tests → writes defect probes →
produces evidence artifact with PASS/FAIL verdict
You: /session-release
Claude: Bumps version → waits for build → packages artifacts →
scans docs site, website, changelog for stale content →
presents checklist → commits release
Task Sequence / Backlog
Beyond per-feature task files, session-flow keeps a standing backlog at todo/SEQUENCE.md — a flat list of one-line entries, each linking to a detailed breakdown:
- [ ] SEQ-007 P2: Add rate limiting to the API → todo/tasks/0007-add-rate-limit.md
- [ ] SEQ-008 P3: Investigate caching layer (needs breakdown)
- [x] SEQ-006 P1: Fix login redirect loop → todo/tasks/0006-fix-login-redirect.md
Each linked breakdown in todo/tasks/ is a self-contained, bite-sized prompt (Files / Instructions / Accept / Test) ready for an agent to execute.
| Want to... | Use |
|---|---|
| Capture something for later | /session-add-task — adds an entry + breakdown |
| Implement the next item | /session-next — or just say "implement the next task" |
| Prepare raw one-liners | /session-groom — researches and attaches breakdowns |
session-init wires a <!-- session-flow:sequence --> block into your CLAUDE.md and AGENTS.md so "implement the next task" works without naming a file. Pair grooming with the built-in /loop for hands-off upkeep:
/loop 30m /session-groom
Gatekeeper / Intake
/session-gatekeeper is the front-of-chain funnel for incoming work — GitHub issues, feature requests, or ideas that surface mid-session. It grounds each item in your architecture docs and product direction (a PRD.md in the docs root by default, configurable via paths.direction), then routes it:
- Trivial, aligned, and clear → straight into the sequence via
session-add-task. - Significant, divergent, or unclear → escalated to a cowork
/session-research-designsession with you. - Off-direction → flagged for your explicit decision.
It triages only — it never implements, and it treats issue text as untrusted data rather than instructions. It pairs with /loop for periodic issue intake, queuing anything significant for you rather than auto-processing it.
Post-Implementation Workflow
/session-post-implementation runs up to 9 steps. At the start, it asks which scope to use:
| Step | Full | Standard | Quick |
|---|---|---|---|
| 1. Simplify | yes | yes | yes |
| 2. Code review | yes | yes | yes |
| 3. Security & liability audit | yes | - | - |
| 4. Commit checkpoint | yes | yes | yes |
| 5. Sanitize | yes | yes | - |
| 6. Test suite | yes | yes | - |
| 7. Architecture docs | yes | - | - |
| 8. Manual test plan | yes | - | - |
| 9. Final commit | yes | yes | - |
Standard and Quick scopes can add individual steps as extras (e.g., Quick + architecture docs). Verification (/session-verify) is always optional and can be invoked after Full completion.
When the security audit is included, you choose how it runs:
- Sub-agent — dispatches an agent (faster, lower cost)
- Inline — runs in the main conversation with your current model (more thorough)
Security & Liability Audit
The audit covers two dimensions:
Technical security — LLM/AI security (prompt injection, unsanitized output, tool validation), OWASP Top 10, secrets detection, agentic security (Lethal Trifecta), desktop app security, dependency supply chain, webhook/integration security. Findings use confidence-based filtering (80% gate) to avoid noise.
Legal liability — ToS/EULA coverage gaps, GDPR compliance (privacy policy, DPAs, data retention, user rights), EU AI Act obligations (risk classification, transparency), Digital Content Directive (conformity, updates), consumer protection (withdrawal, pricing, cancellation), AI output disclaimers, cross-border data transfer requirements. Designed for EU-based developers with a worldwide userbase.
The audit can also run standalone via /security-liability-audit.
Bundled Agents
| Agent | Used By | Purpose |
|---|---|---|
| code-simplifier | post-impl step 1 | Simplify recently changed code |
| code-reviewer | post-impl step 2 | Find bugs, security issues, convention violations |
| security-auditor | post-impl step 3 | Technical security + legal liability audit |
| code-sanitizer | post-impl step 5 | Detect dead code and temporary artifacts |
Bundled agents inherit the parent session's model — an Opus 4.7 session gets Opus 4.7 subagents, a Sonnet session gets Sonnet. If you have the marketplace code-simplifier:code-simplifier plugin installed, session-post-implementation uses it automatically instead of the bundled agent.
Customization
session-flow adapts to your project via .session-flow.json (created by /session-init):
{
"root": "_devdocs",
"paths": {
"research": "_devdocs/research",
"plans": "_devdocs/plans",
"todo": "_devdocs/todo",
"tasks": "_devdocs/todo/tasks",
"sequence": "_devdocs/todo/SEQUENCE.md",
"testing": "_devdocs/testing",
"architecture": "_devdocs/architecture",
"direction": "_devdocs/PRD.md"
}
}
paths.direction points /session-gatekeeper at your product-direction doc. It defaults to a PRD.md inside the docs root (e.g. _devdocs/PRD.md) — let /session-init scaffold it, or set this to an existing PRD/vision file anywhere in the repo.
Override agents by placing custom versions at ~/.claude/agents/ (user) or .claude/agents/ (project). See references/customization-guide.md for details.
Token Budget
Only 1-2 skills are loaded at a time (triggered by description matching):
| Component | Est. Tokens |
|---|---|
| All 13 skill metadata (always loaded) | ~1,300 |
| Largest single skill body (research-design) | ~2,500 |
| Typical active session | ~3,400 |
Security audit reference files (~900 lines total) are only loaded when the audit runs.
References
- Workflow Overview — Full chain diagram, artifact flow, skip patterns
- Customization Guide — Override agents, paths, test runners, release tooling
Contributing
See CONTRIBUTING.md for skill quality checklists and guidelines.
License
Links
- Repository: https://github.com/matshoppenbrouwers/session-flow
- Author: matshoppenbrouwers (hoponthestack)
- Install:
/plugin marketplace add matshoppenbrouwers/session-flow
Keywords: Claude Code plugin · Claude Code skills · Claude Code agents · agentic workflow · development lifecycle automation · task planning · code review · evidence-based verification