Nexusync — Spec-Driven Development

Nexusync is a continuous planning & work management platform — right inside VS Code.
EARS & Standard work breakdown · Nexus of Work Management · AI agent integration · Proactive Planning

Table of Contents

• What is Nexusync?
• The Planning Gap in AI-Assisted Development
• Key Features
• Quick Start
• How It Works
• Plan Breakdown Styles
• Work Item Hierarchy
• Customize AI Behavior with Agent Instructions
• Chat Commands
• MCP Tools for AI Agents
• Two Modes
• Configuration
• Sidebar Views
• Development
• Contributing
• License

What is Nexusync?

Nexusync is a continuous planning & work management platform that bridges the gap between what you want to build and how your AI coding assistant builds it. Describe your project in plain English, and Nexusync generates a rigorous, hierarchical development plan using either the EARS methodology or a Standard work breakdown — then feeds that plan to GitHub Copilot, Cursor, Claude Code, or any MCP-compatible agent as structured context.

The problem: AI coding assistants are powerful but lack project-level context. They implement one file at a time without understanding the full architecture, dependencies, or acceptance criteria.

The solution: Nexusync creates a spec-driven execution plan that your AI agent can follow story-by-story, with clear acceptance criteria, task breakdowns, and status tracking — all managed locally in your workspace. You can also leverage your existing agent instructions (.github/copilot-instructions.md, CLAUDE.md, .cursorrules) to shape how plans are generated and implemented.

The Planning Gap in AI-Assisted Development

Modern AI coding assistants — GitHub Copilot, Cursor, Claude Code — are exceptionally capable at generating code from immediate context. But development teams consistently encounter a critical bottleneck: the absence of structured, upfront planning before the first line of code is written.

The pattern is familiar:

1. A developer opens a chat window and describes a feature in a few sentences
2. The AI generates code — often correct at the file level, but architecturally disconnected from the broader system
3. Dependencies surface mid-implementation. Acceptance criteria are discovered retroactively. Work that should have been parallelized is done sequentially
4. The team ships, then refactors — or worse, accumulates technical debt that compounds across sprints

This is not an AI problem. It is a planning problem.

Engineering teams that invest in deliberate, specification-driven planning before implementation consistently deliver higher-quality software with fewer regressions, clearer ownership, and more predictable timelines. The challenge has been that traditional planning tools live outside the development environment — separate project management tools, wikis, and dashboards — creating a context switch that breaks flow.

Nexusync closes this gap. Plans are generated, stored, and executed inside your editor. Your AI agent receives structured context — not a vague prompt, but a hierarchical breakdown with acceptance criteria, task dependencies, and implementation order. The result: deterministic, spec-driven development where every line of code traces back to a requirement.

"Weeks of coding can save you hours of planning." — Common engineering wisdom

Key Features

Quick Start

1. Install

Search for "Nexusync" in the VS Code Extensions panel, or:

ext install nexusync.nexusync

2. Generate a Plan

Open VS Code Chat (Ctrl+L / Cmd+L) and type:

@nexusync /plan Build a REST API for a task management app with user auth, teams, and real-time notifications

Follow the 5-phase conversational flow:

1. Pick a scope — Simple, Moderate, Complex, or Full-Blown
2. Choose breakdown style — EARS (recommended) or Standard
3. Review themes — Strategic initiative groupings
4. Select themes to expand — Generate epics, stories, and tasks
5. Plan saved — Browse in the sidebar tree

3. Implement with AI

@nexusync /implement

Nexusync orders stories by development phase (infra → backend → frontend → testing → docs), generates instruction files for your AI agent, and tracks progress as you go.

4. Browse & Manage

Click the Nexusync icon in the Activity Bar to see:

• Plans — Hierarchical tree of all plans
• My Work Items — Tasks filtered by assignment/status
• Account — Connection status (local or cloud)

How It Works

  @nexusync /plan "Describe your project"
          │
          ▼
  ┌─────────────────────────────────┐
  │  Phase 1: Scope Analysis        │
  │  Simple · Moderate · Complex    │
  └───────────────┬─────────────────┘
                  ▼
  ┌─────────────────────────────────┐
  │  Phase 2: Breakdown Type        │
  │  EARS  or  Standard             │
  └───────────────┬─────────────────┘
                  ▼
  ┌─────────────────────────────────┐
  │  Phase 3: Strategic Planning    │
  │  Generate Themes, KPIs & Risks  │
  └───────────────┬─────────────────┘
                  ▼
  ┌─────────────────────────────────┐
  │  Phase 4: Theme Expansion       │
  │  Epics → Stories → Tasks        │
  └───────────────┬─────────────────┘
                  ▼
  ┌─────────────────────────────────┐
  │  Phase 5: Save Plan             │
  │  .nexusync/plans/plan-uuid.json │
  └───────────────┬─────────────────┘
                  ▼
  ┌─────────────────────────────────┐
  │  @nexusync /implement           │
  │  AI-assisted story-by-story     │
  └───────────────┬─────────────────┘
                  ▼
  ┌─────────────────────────────────┐
  │  AI Agent Implements            │◄──── done / next
  │  Copilot · Cursor · Claude Code │
  └─────────────────────────────────┘

Plan Breakdown Styles

During Phase 2 of plan generation, you choose between two breakdown approaches. Set the default via nexusync.workBreakdownType in settings.

Standard Work Breakdown

A straightforward decomposition suitable for most projects:

• Themes are split into Epics based on feature areas
• Epics break down into User Stories with plain-language acceptance criteria
• Stories contain Tasks with clear implementation steps
• Best for teams that prefer traditional agile planning without formal requirement patterns
• Acceptance criteria are written as simple bullet points (e.g., "User can log in with email and password")

EARS Methodology

Every acceptance criterion is tagged with one of 6 Easy Approach to Requirements Syntax patterns — producing testable, unambiguous requirements:

The extension calculates EARS coverage percentages and visualizes pattern distribution in the EARS Breakdown Panel. Best for teams that need rigorous, auditable requirements.

Work Item Hierarchy

Theme (th-N)           ← Strategic initiative / product area
  └── Epic (ep-N)      ← Feature group / workstream
       ├── User Story (us-N)  ← User-facing requirement + EARS criteria
       │    └── Task (tk-N)   ← Implementable unit of work
       ├── Issue (is-N)       ← Bug, defect, regression
       └── Vulnerability (vl-N) ← Security finding (CVSS, CVE, CWE)

• Slugs are atomic — counters stored in slug-counters.json, guaranteed unique per workspace
• Status cascades upward — completing all tasks auto-updates story → epic → theme status

Customize AI Behavior with Agent Instructions

Nexusync integrates with your existing AI agent instruction files to shape how plans are generated and implemented. If your workspace already has coding guidelines, architecture conventions, or team preferences defined for your AI tools, Nexusync will pick them up automatically.

Supported Instruction Files

How It Works

1. Plan Generation — When you run @nexusync /plan, Nexusync extracts workspace context including any instruction files it finds. Your coding standards, architecture preferences, and team conventions influence the generated themes, stories, and acceptance criteria.

2. Implementation — When you run @nexusync /implement, the generated instruction blocks reference your existing conventions. If your copilot-instructions.md says "use repository pattern" or your CLAUDE.md says "always write tests first", the AI agent will follow those guidelines while implementing each story.

3. Instruction File Generation — Nexusync can auto-generate or update instruction files (controlled by nexusync.generateInstructionFiles setting). It creates structured implementation blocks that sit alongside your existing instructions, not replacing them.

Example Workflow

If your workspace has:

.github/
  copilot-instructions.md    ← "Use TypeScript strict mode, repository pattern, Jest for tests"
CLAUDE.md                     ← "Follow domain-driven design, async/await for I/O"
.nexusync/
  plans/plan-abc.json         ← Your generated plan

When you /implement, Nexusync produces instruction blocks that combine your conventions with the current story context:

## Current Task: tk-3 — Implement user authentication endpoint

### Workspace Conventions (from your instructions)
- TypeScript strict mode
- Repository pattern
- Jest for tests

### Story Context
- User Story: us-2 — "As a user, I can log in with email and password"
- Acceptance Criteria: [EARS-Event] When valid credentials are submitted, the system shall return a JWT token
- Dependencies: tk-1 (database schema), tk-2 (user model)

This means your AI agent follows your team's standards while implementing Nexusync's structured plan — no manual context-switching needed.

Chat Commands

Open VS Code Chat and type @nexusync followed by a command:

Tip: You can also type natural language — @nexusync create a plan for my e-commerce app auto-routes to /plan.

MCP Tools for AI Agents

Nexusync registers 16 tools via VS Code's Language Model Tools API (vscode.lm.registerTool), making them available to any MCP-compatible agent.

Read-Only Tools

Mutation Tools

Orchestration Tools

Two Modes

Local Mode (Default — Open Source)

your-project/
└── .nexusync/
    ├── config.json            # Mode configuration
    ├── slug-counters.json     # Atomic counters: { th: 3, ep: 7, us: 15, tk: 22 }
    ├── plans/
    │   ├── index.json         # Plan listing for quick loading
    │   └── plan-{uuid}.json   # Full plan with hierarchy
    └── cache/
        └── remote/            # Cached cloud data (connected mode)

• Works completely offline — no server, no account
• Plans stored as JSON in your workspace (version-control friendly)
• Same data model as cloud — transition seamlessly when ready
• Context managed by your AI coding tool (Copilot, Cursor, Claude Code)

Connected Mode (Pro — app.nexusync.io)

• Authenticate with a Personal Access Token (PAT)
• Push/pull plan synchronization with cloud
• Team collaboration across workspaces
• Neo4j knowledge graph & advanced analytics
• Communication via MCP server at mcp.nexusync.io

Switch mode anytime: Command Palette → Nexusync: Switch Mode

Configuration

Sidebar Views

Right-click any item for context actions: View, Edit, Update Status, Add Comment, Link PR, Delete.

Development

Note: The source repository is not yet public. Development setup documentation, contribution guidelines, and issue templates will be available when we open-source the codebase. Star the repository to get notified.

Contributing

We're preparing to open-source this extension. Contribution guidelines, issue templates, and development setup documentation are coming soon.

In the meantime, if you encounter a bug or have a feature request, reach out via nexusync.io.

License

This project is licensed under the MIT License.

Links

• Platform: nexusync.io
• Cloud App: app.nexusync.io
• Documentation: Coming soon
• Changelog: CHANGELOG.md