Intent Sync

Synchronize implementation details back to Intent after development is complete. This makes Intent the true single source of truth.

When to Use

Use /intent-sync when:

• Implementation is complete
• All tests pass
• User has confirmed the implementation works
• You want to capture the finalized design in Intent

What Gets Synced Back

During implementation, many details get finalized that weren't specified in the original Intent:

| Category | Examples | |----------|----------| | Interfaces | API endpoints, function signatures, protocol definitions | | Data Structures | Schema definitions, type definitions, model structures | | Naming | Final class names, function names, variable conventions | | Architecture | Module boundaries, dependency directions, layer structure | | Configuration | Environment variables, config file formats, defaults | | Error Handling | Error codes, error message formats, recovery strategies |

Workflow

User confirms implementation is done
    ↓
Read original Intent file
    ↓
Scan implemented code for:
    - Public interfaces
    - Data structures
    - Key naming conventions
    - Architecture patterns
    ↓
Compare with Intent
    ↓
Identify gaps/differences
    ↓
Present changes for approval
    ↓
Update Intent with confirmed details
    ↓
Mark synced sections with timestamp

Sync Process

Step 1: Gather Implementation Facts

Scan the codebase for finalized details:

Code Analysis:
├── Public APIs
│   ├── Endpoints (REST/GraphQL/RPC)
│   ├── Function signatures
│   └── Event definitions
├── Data Models
│   ├── Database schemas
│   ├── Type definitions
│   └── Config structures
├── Architecture
│   ├── Module structure
│   ├── Dependency graph
│   └── Layer boundaries
└── Conventions
    ├── Naming patterns
    ├── Error formats
    └── Logging standards

Step 2: Compare with Intent

Identify what's new or different:

| Status | Meaning | Action | |--------|---------|--------| | New | Not in original Intent | Add to Intent | | Changed | Different from Intent | Update Intent | | Confirmed | Matches Intent | Mark as implemented | | Removed | In Intent but not implemented | Remove or mark deferred |

Step 3: Present for Approval

Use AskUserQuestion to confirm changes:

"The following details were finalized during implementation.
Should I sync them back to Intent?"

Interfaces:
- [x] POST /api/users - Create user (new)
- [x] UserSchema: added 'createdAt' field (changed)

Data Structures:
- [x] Config now uses YAML instead of JSON (changed)

Naming:
- [x] Service class renamed to UserService (changed)

Step 4: Update Intent

Add a new section or update existing sections:

## Finalized Implementation Details

> Synced on: YYYY-MM-DD
> From: [commit hash or version]

### API Interfaces

| Endpoint | Method | Request | Response |
|----------|--------|---------|----------|
| /api/users | POST | `{name, email}` | `{id, name, email, createdAt}` |
| /api/users/:id | GET | - | `{id, name, email, createdAt}` |

### Data Structures

\`\`\`typescript
interface User {
  id: string;
  name: string;
  email: string;
  createdAt: Date;
}
\`\`\`

### Module Structure

\`\`\`
src/
├── api/
│   └── users.ts       # User endpoints
├── services/
│   └── UserService.ts # Business logic
├── models/
│   └── User.ts        # Data model
└── config/
    └── config.yaml    # Configuration
\`\`\`

### Key Decisions Confirmed

| Decision | Final Choice | Rationale |
|----------|--------------|-----------|
| Config format | YAML | Better readability for nested config |
| ID generation | UUID v4 | Standard, no coordination needed |

Output Format

The sync adds or updates these Intent sections:

New Section: ## Finalized Implementation Details

Contains:

• Sync timestamp
• Source reference (commit/version)
• Concrete interfaces
• Concrete data structures
• Final module structure
• Confirmed decisions

Updated Existing Sections

• Architecture diagrams updated to reflect reality
• Data contracts updated with actual schemas
• API specifications updated with real endpoints

Sync Markers

Use markers to indicate sync status:

## API Design

> [!SYNCED] Last synced: 2024-01-15 from commit abc123

### Endpoints
...

Or in tables:

| Component | Status | Last Synced | |-----------|--------|-------------| | User API | SYNCED | 2024-01-15 | | Auth API | DRAFT | - |

Integration with Other Skills

/intent-interview     # Create Intent (initial)
    ↓
/intent-review        # Approve Intent
    ↓
/intent-plan          # Generate execution plan
    ↓
[Execute: TDD cycles]
    ↓
/intent-sync          # Write back confirmed details (THIS SKILL)
    ↓
/intent-check         # Verify consistency

Best Practices

1. Sync after stability: Don't sync during active development; wait for confirmation
2. Preserve original intent: Keep original design rationale, add implementation details
3. Be specific: Include actual types, actual endpoints, actual names
4. Version reference: Always note which code version was synced
5. Incremental sync: Can sync multiple times as features stabilize

Example Session

User: Implementation is done, tests pass. Please sync back to Intent.