skilld
All skills
wshobson avatar

/parallel-feature-development

@840d219
by Seth Hobsonwshobson/agents40k stars
4,281

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.

Ask your Agent

Use this Skill: https://skilld.dev/gh/wshobson/agents/parallel-feature-development

This session only. Nothing lands on disk.

referencesmerge-strategies.md

≈586 tokens on demand. Your agent reads this file only when SKILL.md points to it.

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

Source: SKILL.md on GitHub

Third-party checks

No alerts16d5 checks · Risk SAFE
  • Gen Agent Trust Hub16d

    The skill provides organizational strategies and architectural guidelines for coordinating multiple AI agents during parallel software development. It focuses on workflow coordination, file ownership, and integration patterns without executing code, performing network operations, or accessing sensitive data.

  • Socket16d

    No alerts

  • Snyk16d

    Risk: LOW · No issues

  • Runlayer7mo

    3 files scanned · No issues

  • ZeroLeaks5mo

    Score: 93/100 · 2 sections analyzed

Provenance

Signed by skilld at 840d219. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 3 days ago.

Activeupdated 6 months ago

Capability

version
1.0.2

Topics

  • multi-agent
  • parallel-development
  • file-ownership
  • integration-patterns
  • conflict-avoidance
  • feature-decomposition
  • vertical-slice
  • horizontal-layer
  • branch-management
  • interface-contracts

README badge

README badge for wshobson/agents/parallel-feature-development

What it does

Coordinates parallel feature development across multiple agents by establishing file ownership strategies, conflict avoidance rules, and integration patterns. Covers vertical slices, horizontal layers, hybrid approaches, and branch management for multi-agent codebases.

Generated from the current SKILL.md.

Frequently asked

What's the difference between vertical slice and horizontal layer decomposition?
Vertical slice assigns each implementer a complete feature (UI + API + tests), while horizontal layer assigns each implementer one architectural layer across all features. Vertical slices minimize integration points but may duplicate utilities; horizontal layers are more consistent but have more dependencies between implementers.
How do I prevent merge conflicts when multiple agents modify the same file?
Enforce one owner per file. If a file must be shared, designate a single owner and have other implementers request changes via message, or extract an interface contract file that all implementers read from but none modify.
Should all implementers work on one branch or separate branches?
Single branch is simpler for small teams (2-3) with clear file ownership; multi-branch gives more isolation for larger teams (4+) but adds merge overhead and still requires careful ownership boundaries.
What are interface contracts and how do I use them?
Interface contracts are read-only type files (owned by the lead) that define boundaries between implementers—for example, an AuthService interface that both the UI and API implementer build against without modifying the contract itself.
How do I handle shared utilities or config files that multiple agents need to modify?
Designate a single owner for all barrel/index files and shared configs. Have the lead merge or coordinate changes to these files at the end, or have one agent own the shared utilities and others request additions via message.

Generated from the current SKILL.md. These answers refresh after source changes.