# What session-flow adds to plain Claude Code, and when to skip it

> What my Claude Code plugin adds over using the agent with nothing installed, and the cases where it is not worth the overhead.

- Type: essay
- Published: 2026-11-22
- Author: Mats Hoppenbrouwers (hoponthestack)
- Canonical URL: https://www.frameworkreboot.com/writing/session-flow-vs-plain-claude-code

[session-flow](/products/session-flow) is my open source Claude Code plugin: sixteen skills, six agents and a `/session-status` command, as of v3.2.0, that arrange the work around the coding into a chain running from triage and design through task planning, parallel dispatch, review and verification to release, with a persistent record kept for each piece of work. Plain Claude Code already does the coding; what the plugin adds is a written-down way of deciding, splitting, checking and remembering work, so that it behaves the same from one session to the next. The rule of thumb: if a job fits in one session and nothing about it needs to be found again later, plain Claude Code is enough.

## What plain Claude Code already does

Plain Claude Code writes the code. In [the essay on why session-flow is a chain](/writing/why-session-flow-is-a-chain) I called the coding the easy part of working with an agent in a terminal. Before the plugin existed I got the rest of the workflow by asking: decide whether this is worth doing, cut it into pieces a session can finish, check the result, ship it. The cost was that I retyped roughly the same instructions in slightly different words, session after session, and got slightly different behaviour each time.

Several things the plugin relies on belong to Claude Code and are there without it. It reads a `CLAUDE.md` file, which costs tokens on every turn of every session. It loads a skill when the skill's description matches what you are asking for. It has a built-in `/loop`, it takes agent definitions from `.claude/agents/`, and its permissions, not my plugin, govern what an agent can touch on disk. It also has a plan mode and can run subagents on its own; the plugin's six agents are subagents in exactly that sense.

## What session-flow adds

**A chain.** [The chain](/glossary/the-chain) is the arrangement of the skills so that each stage produces the artifacts the next one consumes. It is composable rather than mandatory: you enter wherever your work is ready. An existing backlog gets `/session-next`, a plan you wrote yourself gets `/session-task-planning`, a bug gets `/session-debug` and nothing before it.

**A backlog that outlives the session.** Since [version 2](/writing/session-flow-2-0-persistent-work-items), one outcome is one work item with a stable identity such as `SEQ-042`. Its record holds the intent, the scope I accepted and the current status, and a Python runtime validates changes to it. [`SEQUENCE.md`](/glossary/sequence) is generated from those records, one line per open item. Capturing an idea is not acceptance of it.

**Session-sized tasks.** A [session-sized task](/glossary/session-sized-task) is small enough for one agent session to finish: one to five files, clear acceptance criteria, one commit. A larger item gets a [task breakdown](/glossary/task-breakdown), in which each record carries its file paths, instructions, acceptance criteria and test, so an agent can be handed that one record and nothing else.

**Parallel dispatch that is checked.** Tasks declare their dependencies and the paths they may write. `/session-delegation` dispatches implementers in parallel, and the runtime refuses a claim with unfinished or cyclic dependencies, or with declared paths that overlap another actor's live claim. Before the implementers start, a different agent writes the acceptance tests: the [independent test oracle](/glossary/independent-test-oracle). The declared paths are coordination checks, not a sandbox; the runtime does not intercept file writes.

**Verification with evidence.** [Evidence-based verification](/glossary/evidence-based-verification) cites a file and line, a command's output or a test name for every claim, and treats missing evidence as failure. Releasing a feature that has a design document requires a PASS artifact, or an explicit decision to reuse earlier evidence.

**Review agents that report.** The review agents follow one rule: [reporters report, callers filter](/glossary/reporters-report-callers-filter). They return every finding they can tie to a file and a line, labelled high, medium or low confidence. The skill that called them decides what to act on, and then I do.

## Side by side

The middle column is how I worked before the plugin, not a survey of what Claude Code can do.

| Situation | Plain Claude Code | With session-flow |
|-----------|-------------------|-------------------|
| A small, clear job | Ask for it. | Small jobs do not need every step; at most one work record. |
| A bug with an unknown cause | Describe it and steer the diagnosis by hand. | `/session-debug` finds the cause before changing anything, one hypothesis at a time. |
| A feature spanning several sessions | Restate the scope each session. | A work item keeps the accepted scope, plan and tasks under one identity. |
| Tasks that might run at once | Judge by hand which ones can. | Dependencies and declared paths are checked before work is assigned. |
| Deciding whether it is done | Be told it went fine, or ask for proof each time. | `/session-verify` gives a verdict with evidence, and missing evidence counts as failure. |
| Code review | Tell the reviewer how selective to be. | Every finding is reported with a confidence label; the caller filters. |

## When plain Claude Code is enough

I have not measured session-flow against the alternative of just asking an agent for what I want each time. My evidence is that I stopped rewriting the same instructions, which is a weaker claim than it looks. If someone showed me that the gates cost more attention than the mistakes they catch, I would cut gates rather than defend them.

Skipping a stage is a stated rule, with a table in the repository's workflow overview saying what "too small to need this" means for each one. Research and design can be skipped for a small feature of fewer than five files, a well-understood problem, or work you already have a spec for. Task planning can be skipped for a single-task change. Post-implementation can be skipped for a quick fix where polish adds more overhead than value, and verification for a bugfix or a single-file change with no separate spec. Small jobs can stay in a single work record, and a bugfix or refactor release with no design document does not need a verification artifact.

So plain Claude Code is enough when:

- the job fits in one session and leaves nothing a later session has to find;
- there is no backlog to keep, and no second agent whose writes could collide with the first;
- you are satisfied with what you get by asking, and are not retyping the same instructions;
- you cannot meet the runtime's requirements, covered below.

The plugin has a limit of its own too: the runtime checks records, claims and lifecycle transitions, and does not establish that a feature works.

## What it costs

Context first. When I wrote the essay, at v1.7.0 with fifteen skills, I put the standing cost at the skill metadata, around 1,700 tokens, with one or two skill bodies open in a typical session. That figure belongs to that version. The current README, with sixteen skills, gives no number: it says the release does not establish a measured typical token budget, and that actual context use depends on the host, the workflow you pick, the repository and the conversation.

Then setup. Since version 2 the plugin needs Python 3.9 or newer reachable as `python3`, on Linux, macOS or WSL; native Windows is unsupported. `/session-init` creates a documentation structure in the repository, `_devdocs/` by default, and wires a block into `CLAUDE.md` and `AGENTS.md`.

Then attention, which is the cost I would watch. Every stage pauses at its decision points and asks: you approve the scope before execution, and the breakdown before its tasks are accepted. Those pauses are the gates, worth having only while they catch more than they cost.

## How to try it

Install it from inside Claude Code:

```
/plugin marketplace add matshoppenbrouwers/session-flow
/plugin install session-flow@session-flow
```

Confirm `python3 --version` reports 3.9 or newer, then run `/session-init` once. From there, `/session-add-task` captures a small job and `/session-research-design` develops a feature. The source is MIT licensed at [github.com/matshoppenbrouwers/session-flow](https://github.com/matshoppenbrouwers/session-flow).
