The Problem

Claude Code is remarkably capable...until your context window fills up. As tokens accumulate during a long session, reasoning quality degrades, hallucinations increase, and the model starts losing track of earlier decisions. This is context rot, and it's the primary failure mode when building anything beyond a single-session project.

Towline solves this. It keeps your main orchestrator under ~15% context usage by delegating heavy work to fresh subagent contexts, each getting a clean 200k token window. All state lives on disk. Sessions are killable at any second without data loss. Whether you're on a free tier or Max 5x, wasted context means wasted budget, and context rot is the biggest source of waste.

Why Towline?

Most AI coding tools treat context as infinite. They index your codebase, track your edits, and hope the model keeps up. That works for single-file changes. It falls apart when you're building something that takes days, spans dozens of files, and requires decisions made on Monday to still hold on Friday.

Towline takes a different approach: structured context isolation. Instead of stuffing everything into one session, it delegates each operation to a fresh subagent with a clean 200k token window and coordinates through files on disk.

Goal-backward verification, lifecycle hooks, wave-based parallelism, kill-safe state, and more. See What Sets It Apart for the full comparison and differentiators.

When to use Towline: Multi-phase projects where quality matters. New features spanning 5+ files, large refactors, greenfield builds, anything that would take more than one Claude Code session to complete. Use depth: quick or depth: standard to control agent spawn count per phase.

When to skip it: Single-file fixes, quick questions, one-off scripts. Use /dev:quick for atomic commits without full workflow overhead: single executor spawn, no research or verification agents.

Works on every Claude Code plan. Use depth: quick on Free/Pro, depth: standard on Max, depth: comprehensive on Max 5x. See What Sets It Apart for tier-specific guidance.

Getting Started

Prerequisites

• Claude Code 2.1.45+  (claude --version)
• Node.js 18+

Install

# From your terminal
claude plugin marketplace add SienkLogic/towline
claude plugin install dev@towline

# Or from inside a Claude Code session
/plugin marketplace add SienkLogic/towline
/plugin install dev@towline

All /dev:* commands are now available globally.

| Scope | Command | Effect | |-------|---------|--------| | Global (default) | claude plugin install dev@towline | Available in all projects | | Project only | claude plugin install dev@towline --scope local | This project only, gitignored | | Team project | claude plugin install dev@towline --scope project | Shared via git, teammates get prompted |

Dashboard (Optional)

Towline ships with a companion web dashboard for browsing your project's planning state in a browser. To set it up:

# One-time install of dashboard dependencies
npm run dashboard:install

# Launch the dashboard for any project with a .planning/ directory
npm run dashboard -- --dir /path/to/your/project
# Opens at http://127.0.0.1:3000

Or run directly:

node dashboard/bin/cli.js --dir /path/to/your/project --port 3000

Quick Start (Max / Max 5x)

Full pipeline with parallel research and multi-agent builds. Best experience.

cd your-project && claude

/dev:begin                # Towline asks about your project, researches the domain,
                          # scopes requirements, and generates a phased roadmap

/dev:plan 1               # Research + plan the first phase
/dev:build 1              # Build it with parallel agents, atomic commits
/dev:review 1             # Verify the codebase matches requirements
/dev:plan 2               # Repeat for next phase

That's the whole cycle. Everything lands in a .planning/ directory. Kill your terminal anytime, /dev:resume picks up where you left off.

Quick Start (Pro / Free)

Lighter workflow that still gives you structured state tracking and clean commits.

cd your-project && claude

/dev:setup                # Create .planning/ structure without the heavy research step
/dev:plan 1 --skip-research   # Plan without spawning a research agent
/dev:build 1              # Build it
/dev:quick                # For one-off tasks: single agent, atomic commit, lowest cost

Set depth: quick in /dev:config to reduce agent spawns across all workflows.

Quick Reference

| What you want | Command | |---------------|---------| | Start a new project | /dev:begin (or /dev:setup for lightweight init) | | Plan a phase | /dev:plan 1 | | Build a phase | /dev:build 1 | | Verify a phase | /dev:review 1 | | Do something quick | /dev:quick | | See where you are | /dev:status | | Resume after restart | /dev:resume | | Auto-advance | /dev:continue | | Change settings | /dev:config |

Commands

Core Workflow

| Command | Description | Agents | |---------|-------------|--------| | /dev:begin | Start a new project: questioning, research, requirements, roadmap | 4-6 (quick: 2-3) | | /dev:plan <N> | Plan a phase: research, plan creation, verification loop | 2-3 (quick: 1-2) | | /dev:build <N> | Build a phase: parallel execution in waves, atomic commits | 2-4 (quick: 1-2) | | /dev:review <N> | Verify a phase: automated 3-layer checks + conversational UAT | 1 |

See Commands for all 21 commands with flags, cost-by-depth tables, and detailed descriptions.

How It Works

Towline is a thin orchestrator that delegates heavy work to fresh subagent contexts via Task(). Data flows through files on disk, not through messages.

Main Session (~15% context)
  │
  ├── Task(researcher)  ──▶  writes .planning/research/
  ├── Task(planner)     ──▶  writes PLAN.md files
  ├── Task(executor)    ──▶  builds code, creates commits
  ├── Task(executor)    ──▶  (parallel, same wave)
  └── Task(verifier)    ──▶  checks codebase against must-haves

See Architecture for key concepts, the token-saving CLI, data flow details, and supporting directories.

Deep Dive

| Topic | Description | |-------|-------------| | Agents | 10 specialized agents with configurable model profiles and file-based communication | | Configuration | 12 config keys, depth/model profiles, 16+ feature toggles | | Hooks | 15 lifecycle hooks that enforce discipline at zero token cost | | Project Structure | The .planning/ directory layout, key files, and file ownership | | Dashboard | Web UI with live updates for browsing project state | | Philosophy | Design principles and platform alignment strategy | | What Sets It Apart | Feature comparison and key differentiators |

Local Development

# Clone and install
git clone https://github.com/SienkLogic/towline.git
cd towline
npm install

# Run tests (758 tests, 36 suites)
npm test

# Lint
npm run lint

# Validate plugin structure
npm run validate

# Load locally for manual testing
claude --plugin-dir .

CI runs on Node 18/20/22 across Windows, macOS, and Linux. See CONTRIBUTING.md for guidelines.

Stats

| Metric | Count | |--------|-------| | Skills (slash commands) | 21 | | Specialized agents | 10 | | Hook scripts | 28 | | Tests | 758 | | Test suites | 36 | | Config toggles | 12 top-level keys |

License

MIT