Agent skill

Parallel Feature Development

by wshobson in wshobson/agents

Coordinate parallel feature development with file ownership strategies, conflict avoidance rules, and integration patterns for multi-agent implementation.

MITAuto-check passedDevelopment

Install Parallel Feature Development

skills CLI
$ npx skills add wshobson/agents --skill parallel-feature-development -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install wshobson/agents parallel-feature-development --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/wshobson/agents.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/agent-teams/skills/parallel-feature-development .claude/skills/parallel-feature-development && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
parallel-feature-development
GitHub stars
40k
Token cost
~1.7k tokens
SKILL.md length
576 words
Files
3 (incl. references)
Skills in repo
142
Repo updated
First seen
Licence
MIT

At a glance

Coordinate parallel feature development with file ownership strategies, conflict avoidance rules, and integration patterns for multi-agent implementation.

  • Works in 4 steps: Designate a single owner — One… → Other implementers request changes —… → Owner applies changes sequentially —… → …
  • Decomposing a large feature into independent work streams
  • SKILL.md covers When to Use This Skill, File Ownership Strategies, Conflict Avoidance Rules and Integration Patterns, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Parallel Feature Development is an agent skill from wshobson/agents. 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…

Its SKILL.md is about 1.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/file-ownership.md` and `references/merge-strategies.md`).

It sits in Development, covering Third-party API integration and Git workflow. The repository describes itself as: Multi-harness agentic plugin marketplace for Claude Code, Codex, Cursor, OpenCode, GitHub Copilot, Google Antigravity, and Pi. The licence is MIT.

When your agent uses it

  • Decomposing a large feature into independent work streams
  • More agents need to implement different layers of the same system simultaneously
  • Establishing file ownership to prevent merge conflicts in a shared codebase
  • Designing interface contracts so parallel implementers can build against each others APIs before they are ready

Example prompts

  • “/parallel-feature-development”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Designate a single owner — One implementer owns the file
  2. Other implementers request changes — Message the owner with specific change requests
  3. Owner applies changes sequentially — Prevents merge conflicts
  4. Alternative: Extract interfaces — Create a separate interface file that the non-owner can import without modifying

What it can do on your machine

Read from SKILL.md and the folder at commit 46891e7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are typescript).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Parallel Feature Development loads about 1.7k tokens when it runs, and up to ~2.9k if it reads all its reference files. Until then it costs about 164 tokens; SKILL.md has 576 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~164
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~2.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from wshobson/agents at commit 46891e7, republished under its MIT licence (© wshobson). 576 words, ~1,658 tokens.

Download SKILL.mdSave it as .claude/skills/parallel-feature-development/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
parallel-feature-development
description
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.
version
1.0.2

Parallel Feature Development

Strategies for decomposing features into parallel work streams, establishing file ownership boundaries, avoiding conflicts, and integrating results from multiple implementer agents.

When to Use This Skill

  • Decomposing a feature for parallel implementation
  • Establishing file ownership boundaries between agents
  • Designing interface contracts between parallel work streams
  • Choosing integration strategies (vertical slice vs horizontal layer)
  • Managing branch and merge workflows for parallel development

File Ownership Strategies

By Directory

Assign each implementer ownership of specific directories:

implementer-1: src/components/auth/
implementer-2: src/api/auth/
implementer-3: tests/auth/

Best for: Well-organized codebases with clear directory boundaries.

By Module

Assign ownership of logical modules (which may span directories):

implementer-1: Authentication module (login, register, logout)
implementer-2: Authorization module (roles, permissions, guards)

Best for: Feature-oriented architectures, domain-driven design.

By Layer

Assign ownership of architectural layers:

implementer-1: UI layer (components, styles, layouts)
implementer-2: Business logic layer (services, validators)
implementer-3: Data layer (models, repositories, migrations)

Best for: Traditional MVC/layered architectures.

Conflict Avoidance Rules

The Cardinal Rule

One owner per file. No file should be assigned to multiple implementers.

When Files Must Be Shared

If a file genuinely needs changes from multiple implementers:

  1. Designate a single owner — One implementer owns the file
  2. Other implementers request changes — Message the owner with specific change requests
  3. Owner applies changes sequentially — Prevents merge conflicts
  4. Alternative: Extract interfaces — Create a separate interface file that the non-owner can import without modifying
Interface Contracts

When implementers need to coordinate at boundaries:

typescript
// src/types/auth-contract.ts (owned by team-lead, read-only for implementers)
export interface AuthResponse {
  token: string;
  user: UserProfile;
  expiresAt: number;
}

export interface AuthService {
  login(email: string, password: string): Promise<AuthResponse>;
  register(data: RegisterData): Promise<AuthResponse>;
}

Both implementers import from the contract file but neither modifies it.

Integration Patterns

Vertical Slice

Each implementer builds a complete feature slice (UI + API + tests):

implementer-1: Login feature (login form + login API + login tests)
implementer-2: Register feature (register form + register API + register tests)

Pros: Each slice is independently testable, minimal integration needed. Cons: May duplicate shared utilities, harder with tightly coupled features.

Horizontal Layer

Each implementer builds one layer across all features:

implementer-1: All UI components (login form, register form, profile page)
implementer-2: All API endpoints (login, register, profile)
implementer-3: All tests (unit, integration, e2e)

Pros: Consistent patterns within each layer, natural specialization. Cons: More integration points, layer 3 depends on layers 1 and 2.

Hybrid

Mix vertical and horizontal based on coupling:

implementer-1: Login feature (vertical slice — UI + API + tests)
implementer-2: Shared auth infrastructure (horizontal — middleware, JWT utils, types)

Best for: Most real-world features with some shared infrastructure.

Branch Management

Single Branch Strategy

All implementers work on the same feature branch:

  • Simple setup, no merge overhead
  • Requires strict file ownership to avoid conflicts
  • Best for: small teams (2-3), well-defined boundaries
Multi-Branch Strategy

Each implementer works on a sub-branch:

feature/auth
  ├── feature/auth-login      (implementer-1)
  ├── feature/auth-register    (implementer-2)
  └── feature/auth-tests       (implementer-3)
  • More isolation, explicit merge points
  • Higher overhead, merge conflicts still possible in shared files
  • Best for: larger teams (4+), complex features
Show full SKILL.md (224 more words)Show less

Troubleshooting

Implementers are blocking each other waiting for shared code. Extract the shared piece into its own interface contract file owned by the team-lead and have implementers import from it. Neither implementer modifies the contract — they only implement against it.

Merge conflicts appear even with clear ownership rules. A file was assigned to two agents, or a config/index file (e.g., index.ts, __init__.py) that auto-imports everything was modified by both. Designate one owner for all barrel/index files, or have the lead merge them at the end.

An implementer finishes early but the integration step is blocked. Use a staging interface: the finished implementer writes a stub or mock of the downstream dependency so the other implementer can continue working. Replace with the real implementation at integration time.

The feature decomposition turned out wrong mid-stream. Stop new work, have the lead redistribute files, and communicate the change via broadcast. Sunk cost on partially written code is acceptable — continuing with the wrong split is worse.

Tests written by one implementer fail against code written by another. Interface contracts drifted: the implementer who owns the API changed a signature without notifying the test implementer. Enforce the rule that contract files require a broadcast before modification.

© wshobson, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in plugins/agent-teams/skills/parallel-feature-development of wshobson/agents.

  • SKILL.md
  • references/file-ownership.md
  • references/merge-strategies.md

Open the folder on GitHubat commit 46891e7

Compare with similar skills

Parallel Feature Development next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Parallel Feature Development compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Parallel Feature Development this skillwshobson/agents40k—~1.7kAutomated safety check: PassMIT
Merge Strategymarcus/sidecar1.1k—~2.1kAutomated safety check: PassMIT
Commit Context Lookuprohitg00/agentmemory29k—~522Automated safety check: PassApache-2.0
Mirage VFS Adapter Authoringstrukto-ai/mirage3.7k—~2.4kAutomated safety check: PassApache-2.0
Jevgrepdzhng/jevgrep2.4k—~741Automated safety check: PassMIT
Git Worktree IsolationjnMetaCode/superpowers-zh8.3k1 repos~982Automated safety check: PassMIT

Similar skills

  • Merge Strategy

    marcus/sidecar

    Git merge strategies, conflict resolution approaches, merge vs rebase recommendations, and branch integration patterns in sidecar.

    1.1k GitHub stars~2.1k tokensUpdated 2 days ago
    DevelopmentAuto-check passed
  • Commit Context Lookup

    rohitg00/agentmemory

    Traces a file, function or line back to the agent session behind its current commit, using git blame and a memory lookup, and reports only what the records show.

    29k GitHub stars~522 tokensUpdated today
    DevelopmentAuto-check passed
  • Builds or extends a custom Mirage virtual filesystem adapter for an API, database, object store or app data, with a working mount configuration and filesystem tests.

    3.7k GitHub stars~2.4k tokensUpdated today
    DevelopmentAuto-check passed
  • Jevgrep

    dzhng/jevgrep

    A skill your agent uses for questions about how, why, or where behavior works in a repository, including questions that name a function or setting.

    2.4k GitHub stars~741 tokensUpdated 4 days ago
    DevelopmentAuto-check passed
  • Git Worktree Isolation

    jnMetaCode/superpowers-zh

    Sets up an isolated workspace before feature work or plan execution, preferring native worktree tools and falling back to git worktree, with instructions in Chinese.

    8.3k GitHub starsUsed in 1 repo~982 tokens
    DevelopmentAuto-check passed
  • Agentic Jujutsu

    ruvnet/agentic-flow

    Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination

    816 GitHub starsUsed in 4 repos~4.7k tokens
    DevelopmentAuto-check passed

More from wshobson/agents

All 142 skills in this repo
  • Cuts cloud spend across AWS, Azure, GCP and OCI with cost tagging, rightsizing, commitment and spot pricing models, and architecture changes.

    40k GitHub starsUsed in 13 repos~1.7k tokens
    Auto-check passed
  • Billing Automation

    wshobson/agents

    Covers building subscription billing: billing cycles, subscription states, invoice generation, proration, tax handling and dunning for failed payments.

    40k GitHub starsUsed in 12 repos~473 tokens
    Auto-check passed
  • Profiles slow Python code with cProfile and memory profilers, then applies targeted fixes for CPU, memory, I/O and query bottlenecks.

    40k GitHub starsUsed in 12 repos~814 tokens
    Auto-check passed
  • Portfolio Risk Metrics

    wshobson/agents

    Covers portfolio risk measurement with VaR, CVaR, Sharpe, Sortino and drawdown, plus guidance on limits, stress tests and tail risk.

    40k GitHub starsUsed in 12 repos~502 tokens
    Auto-check passed
  • Plans memory headroom, works through out-of-memory failures and watches temperature and power during long ML training jobs on NVIDIA DGX Spark.

    40k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed
  • Writes unit tests for shell scripts with Bats: error-condition tests, fixtures and mocks, cross-shell checks, parallel runs, helper files and CI integration.

    40k GitHub starsUsed in 11 repos~1.3k tokens
    Auto-check passed

Questions about Parallel Feature Development

What does Parallel Feature Development do?

Coordinate parallel feature development with file ownership strategies, conflict avoidance rules, and integration patterns for multi-agent implementation. Parallel Feature Development is an agent skill from wshobson/agents. Coordinate parallel feature development with file ownership strategies, conflict avoidance rules, and integration patterns for multi-agent implementation.

When should I use Parallel Feature Development?

Parallel Feature Development fits situations like: decomposing a large feature into independent work streams; more agents need to implement different layers of the same system simultaneously; establishing file ownership to prevent merge conflicts in a shared codebase; designing interface contracts so parallel implementers can build against each others APIs before they are ready.

How do I install Parallel Feature Development in Claude Code?

Run `npx skills add wshobson/agents --skill parallel-feature-development -a claude-code`. Or copy the skill folder (plugins/agent-teams/skills/parallel-feature-development in wshobson/agents) into .claude/skills/parallel-feature-development in your project. Claude Code loads it when a task matches its description.

How do I install Parallel Feature Development in Codex?

Run `npx skills add wshobson/agents --skill parallel-feature-development -a codex`. Or copy the skill folder (plugins/agent-teams/skills/parallel-feature-development in wshobson/agents) into .agents/skills/parallel-feature-development in your project. Codex loads it when a task matches its description.

Can I use Parallel Feature Development in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add wshobson/agents --skill parallel-feature-development -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/parallel-feature-development, .gemini/skills/parallel-feature-development, .github/skills/parallel-feature-development and .opencode/skills/parallel-feature-development in your project.

What does Parallel Feature Development need to run?

SKILL.md names no scripts, command-line tools or credentials: Parallel Feature Development is instructions for the agent only.

Does Parallel Feature Development access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Parallel Feature Development safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Parallel Feature Development use?

Parallel Feature Development is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Parallel Feature Development use?

About 1.7k tokens (SKILL.md is roughly 6.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.2k tokens, read only when the agent opens those files.

What are the alternatives to Parallel Feature Development?

Skills that share tags, products or a category with Parallel Feature Development: Merge Strategy (marcus/sidecar, 1.1k stars), Commit Context Lookup (rohitg00/agentmemory, 29k stars), Mirage VFS Adapter Authoring (strukto-ai/mirage, 3.7k stars) and Jevgrep (dzhng/jevgrep, 2.4k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Parallel Feature Development?

wshobson (a GitHub user) maintains it in wshobson/agents, which has 40,254 GitHub stars. The repository holds 142 skills in this directory. The repository was last updated on October 5, 2026.

Source: wshobson/agents on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.