AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

parallel-feature-development

Coordinate parallel feature development with file ownership strategies, conflict avoidance rules, and integration patterns for multi-agent implementation. Use this skill when decomposing a large feature into independent work streams, when two or more agents need to implement different layers of the same system simultaneously, when establishing file ownership to prevent merge conflicts in a shared codebase, when designing interface contracts so parallel implementers can build against each other's APIs before they are ready, or when deciding whether to use vertical slices versus horizontal layers for a full-stack feature.

Original source
wshobson
License
MIT
Pinned revision
7e2fb559cf4b824b27f1fec49fe88f7511066d26

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

Ask your assistant

Use Agentic Memory skills to read wshobson--parallel-feature-development at revision 7e2fb559cf4b824b27f1fec49fe88f7511066d26, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 3

references/merge-strategies.md

Integration and Merge Strategies

Patterns for integrating parallel work streams and resolving conflicts.

Integration Patterns

Pattern 1: Direct Integration

All implementers commit to the same branch; integration happens naturally.

feature/auth ← implementer-1 commits
             ← implementer-2 commits
             ← implementer-3 commits

When to use: Small teams (2-3), strict file ownership (no conflicts expected).

Pattern 2: Sub-Branch Integration

Each implementer works on a sub-branch; lead merges them sequentially.

feature/auth
  ├── feature/auth-login     ← implementer-1
  ├── feature/auth-register  ← implementer-2
  └── feature/auth-tests     ← implementer-3

Merge order: follow dependency graph (foundation → dependent → integration).

When to use: Larger teams (4+), overlapping concerns, need for review gates.

Pattern 3: Trunk-Based with Feature Flags

All implementers commit to the main branch behind a feature flag.

main ← all implementers commit
     ← feature flag gates new code

When to use: CI/CD environments, short-lived features, continuous deployment.

Integration Verification Checklist

After all implementers complete:

  1. Build check: Does the code compile/bundle without errors?
  2. Type check: Do TypeScript/type annotations pass?
  3. Lint check: Does the code pass linting rules?
  4. Unit tests: Do all unit tests pass?
  5. Integration tests: Do cross-component tests pass?
  6. Interface verification: Do all interface contracts match their implementations?

Conflict Resolution

Prevention (Best)

  • Strict file ownership eliminates most conflicts
  • Interface contracts define boundaries before implementation
  • Shared type files are owned by the lead and modified sequentially

Detection

  • Git merge will report conflicts if they occur
  • TypeScript/lint errors indicate interface mismatches
  • Test failures indicate behavioral conflicts

Resolution Strategies

  1. Contract wins: If code doesn't match the interface contract, the code is wrong
  2. Lead arbitrates: The team lead decides which implementation to keep
  3. Tests decide: The implementation that passes tests is correct
  4. Merge manually: For complex conflicts, the lead merges by hand