Features / Plans

Agent-assisted plans with human control.

Structured plans translate intent into safe, bounded execution so your team decides what agents do—and what they never touch.

Agents draft plans. Humans approve them.

Plan snapshot

Goal

Add audit logging to user settings service without downtime.

Scope

Update `services/settings` handlers
Add redact helper in `lib/logging`
No DB schema changes

The problem

Traditional planning breaks down with AI. Humans outline work in documents; agents act directly in code. Alignment is implied instead of explicit, and review happens after changes exist.

That gap leads to agent drift, scope creep, and late surprises—the worst time to discover them.

The core idea

A Plan is a shared contract between human intent and agent execution, with structure in between to keep them aligned.

It is concept-first, not prose-first.

How planning actually works

1
You describe the goal and constraints.
Capture intent, boundaries, and what must not change.
2
An agent proposes a structured plan.
It is machine-readable, not markdown, so scope is explicit.
3
You review and refine in the UI.
Edit, add exclusions, and confirm intent before any code is touched.
4
The approved plan guides execution.
It becomes the boundary agents must stay inside during implementation.

Why the UI matters

Review intent before reviewing code.
Catch scope creep early, not after a PR exists.
See impact up front; code review should not be the first time you see what an agent did.

Role of agents (MCP)

Agents operate through MCP and consume the same structured plan you approve.
Plans are machine-readable so boundaries are enforceable, not implied.
Agents stay inside the defined scope instead of improvising.

What a Plan contains

Clear goals
Work items
Intended file-level changes
Explicit constraints and exclusions

Relationship to Code Alerts

Plans benefit from Code Alerts by highlighting risky areas up front, so proposals factor in complexity hotspots before changes ship.