AI is powerful.
AI is unreliable.
Both are true.
An open-source orchestration framework that brings structure, enforcement, and multi-agent verification to AI-assisted development.
pipx install workscope-dev Not a better prompt.
A better process.
Some developers won't let AI near their architecture. Others generate entire features from a sentence and hope for the best. The skeptics have good reasons - LLMs hallucinate, drift, and ignore instructions. The enthusiasts have good reasons too, and the leverage is unlike anything we've had before. WSD is for both: the rigor of disciplined engineering with the reach of AI-assisted development.
Most approaches to improving AI output focus on writing better instructions. Craft a more detailed prompt. Add more context. Fine-tune the rules file. This is like solving software engineering by writing better code comments. It helps on the margins.
WSD engineers the entire workflow around AI development. It picks the right task, loads the right context, verifies the output, and carries knowledge forward between sessions. The system handles the discipline so the AI can focus on the work.
Your AI assistant is already smart enough. What it lacks is structure.
Who It's For
WSD is for developers who've gotten past the honeymoon phase with AI coding tools. You know they work. You also know they break in weird ways when nobody's watching.
If you've ever spent more time managing your AI agents than actually building, this is the fix.
The Problem Nobody
Wants to Admit
You've seen it happen. The assistant charges through your codebase like it owns the place. Rewrites files you told it to leave alone. Forgets your rules by paragraph three. Produces code that looks right until you read the details. Tomorrow, it won't remember any of it.
The tool isn't broken. The workflow around it is.
Every AI session starts from zero. No memory of yesterday's decisions, no awareness of the codebase's history, no idea what you've already tried. You rebuild context from scratch every time.
You wrote careful rules. The AI followed them for a while, then quietly stopped. Half your conventions are violated by the time you notice, and untangling it takes longer than writing the code yourself would have.
Reviewing every line of AI-generated code wipes out the productivity gain. But accepting it on faith is reckless. You're stuck in a loop where the tool saves time and the overwatch costs it back.
How WSD Works
The System
Bounded Workscopes
Each AI session gets a formally defined workscope: a precisely scoped unit of work derived from your project's own task hierarchy, sized to fit within a single context window. Immutable once assigned - the AI can't talk itself out of the work, redefine what "done" means, or gradually drift from the original intent. Every workscope carries a unique identifier that threads from assignment through quality review to completion.
Context Engineering
Output quality tracks directly to context quality. WSD automates the curation: specialist agents figure out which docs, code files, and standards are relevant to each task. Not drinking from a firehose, and not flying blind. Precision over volume.
Enforcement and Verification
Rules files are suggestions the AI can (and will) ignore. WSD replaces your pleas with specialist agents that independently review completed work against your project's laws, with domain authority and the power to reject submissions that don't comply.
WSD watches the watchers. Every reviewer must provide proof-of-work: evidence the review actually happened, not just a verdict. Test results must include actual output from the test runner. Health checks must include the summary table from the quality script. If an agent can't show its work, the system rejects the approval.
Persistence & Knowledge
The Memory
AI sessions are ephemeral. Projects aren't. WSD is built around this distinction.
Institutional Memory
WSD carries context forward through structured documentation, work journals, and a living workbench. Best practices and project-specific decisions are codified. Session 10 knows what session 1 learned.
Document-Driven Engineering
In most projects, docs are an afterthought. WSD makes documentation the operating system. Your specs, tickets, and action plans are the inputs the system reads to determine what gets built, what gets fixed, and what gets assigned next. The task manager reads the action plan. The documentation steward compares code against the spec and can reject work that doesn't match.
Your project's task list lives inside your documentation in hierarchical checklists embedded directly in your feature specs and action plans. Your TODO list is your documentation, and your documentation is your project plan.
Just Files. Zero Dependencies.
WSD is Markdown documents, standard-library scripts, and configuration files. No packages to download. No build step. No runtime. WSD integrates with your tools: your linter, your test runner, your type checker... but depends on none of them.
Install it and it works. Remove it and nothing breaks.
Beyond Code
WSD works at the workflow level. Libraries, CLI tools, full-stack applications... it detects what's available and adapts. But the workscope lifecycle turns out to be useful for any sustained AI-assisted work: book projects, research studies, planning exercises. Anywhere the same problems apply (scoping, context, accountability), WSD applies too.
What does it actually
look like?
You run a single command. The system reads your project's state, finds the next piece of work from your task lists, and assigns it. Before coding starts, specialist agents have loaded the relevant documentation and code context and briefed the AI on your project's conventions.
Then the AI works. Not on a vague goal, but on a precise, documented assignment with clear boundaries.
When the work is done, independent reviewers check it from multiple angles before you see it. Spec compliance, standards, tests, code health. If something's off, it goes back for revision.
What you get is finished work that's been reviewed, with a clear audit trail. Not a pile of code to check line-by-line.
Four commands. One complete cycle.
-
/wsd:initThe system reads your project. Identifies the next piece of work. Assigns it.
-
/wsd:prepareContext agents gather the docs, code files, and standards the AI needs.
-
/wsd:executeThe AI works within bounded scope. Independent agents verify the result.
-
/wsd:closeDocuments archived. Task lists updated. Clean handoff for the next session.
The long-term winners won't be the developers with the best prompts. They'll be the ones with the best process.
The Bigger Picture
We believe coding as we know it will eventually fade, much like assembly programming receded after compilers arrived. The developers of tomorrow won't write Python directly any more than today's developers write bytecode. They'll work in specifications, designs, constraints, and intentions, and AI will compile those documents into the code that brings them to life.
WSD isn't that future. Not yet. But the practices we're developing now: bounded workscopes, context engineering, post-hoc enforcement, document-driven engineering... these are the seeds of whatever comes next. Managing a body of structured documents, keeping them organized, accurate, and cross-referenced, is becoming a core engineering skill.
This is the trail we're cutting.