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.

referencesfile-ownership.md

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

File Ownership Decision Framework

How to assign file ownership when decomposing features for parallel development.

Ownership Decision Process

Step 1: Map All Files

List every file that needs to be created or modified for the feature.

Step 2: Identify Natural Clusters

Group files by:

  • Directory proximity (files in the same directory)
  • Functional relationship (files that import each other)
  • Layer membership (all UI files, all API files)

Step 3: Assign Clusters to Owners

Each cluster becomes one implementer's ownership boundary:

  • No file appears in multiple clusters
  • Each cluster is internally cohesive
  • Cross-cluster dependencies are minimized

Step 4: Define Interface Points

Where clusters interact, define:

  • Shared type definitions (owned by lead or a designated implementer)
  • API contracts (function signatures, request/response shapes)
  • Event contracts (event names and payload shapes)

Ownership by Project Type

React/Next.js Frontend

implementer-1: src/components/{feature}/   (UI components)
implementer-2: src/hooks/{feature}/        (custom hooks, state)
implementer-3: src/api/{feature}/          (API client, types)
shared:        src/types/{feature}.ts      (owned by lead)

Express/Fastify Backend

implementer-1: src/routes/{feature}.ts, src/controllers/{feature}.ts
implementer-2: src/services/{feature}.ts, src/validators/{feature}.ts
implementer-3: src/models/{feature}.ts, src/repositories/{feature}.ts
shared:        src/types/{feature}.ts      (owned by lead)

Full-Stack (Next.js)

implementer-1: app/{feature}/page.tsx, app/{feature}/components/
implementer-2: app/api/{feature}/route.ts, lib/{feature}/
implementer-3: tests/{feature}/
shared:        types/{feature}.ts          (owned by lead)

Python Django

implementer-1: {app}/views.py, {app}/urls.py, {app}/forms.py
implementer-2: {app}/models.py, {app}/serializers.py, {app}/managers.py
implementer-3: {app}/tests/
shared:        {app}/types.py              (owned by lead)

Conflict Resolution

When two implementers need to modify the same file:

  1. Preferred: Split the file — Extract the shared concern into its own file
  2. If can't split: Designate one owner — The other implementer sends change requests
  3. Last resort: Sequential access — Implementer A finishes, then implementer B takes over
  4. Never: Let both modify the same file simultaneously

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.