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.

Quality

—

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Quality

Content

70%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A well-structured, genuinely useful patterns skill with clear decision frameworks and a troubleshooting section, but it loses points for verbosity across near-duplicate sections and for failing to integrate its own reference bundle into the body via signaled links.

Suggestions

Link and signal the existing references/ files (e.g. 'See [file-ownership.md](references/file-ownership.md) for detailed ownership rules') so the bundle is discoverable rather than orphaned, and move the verbose ownership/integration detail there to slim the main body.

Tighten the three ownership strategies and three integration patterns by collapsing repetitive 'Best for' annotations into a single comparison table, reducing token cost without losing clarity.

Convert the illustrative directory-assignment and branch-tree blocks into either concrete copy-paste commands or a single parameterized example, raising actionability from descriptive to executable.

Dimension	Reasoning	Score
Conciseness	The body is mostly efficient and avoids explaining concepts Claude already knows, but the proliferation of near-parallel sections (three ownership strategies, three integration patterns, two branch strategies each with 'Best for' annotations) could be tightened; some 'Best for' lines and overlapping examples earn less than full token efficiency.	2 / 3
Actionability	Guidance is concrete in places (the TypeScript interface contract is executable, branch trees are specific), but several examples are illustrative assignment tables and directory layouts rather than copy-paste commands, and the conflict-avoidance rules describe procedure without executable steps.	2 / 3
Workflow Clarity	As a strategy/patterns skill it has clear sequencing within decision areas and a strong Troubleshooting section mapping failures to fixes; no destructive/batch operation is present that would require validate-fix-retry loops, so the simple-skill allowance applies.	3 / 3
Progressive Disclosure	The body is well-organized into clear sections, but the two existing reference files (references/file-ownership.md and references/merge-strategies.md) are never signaled or linked from the body, leaving the bundle disconnected; content that could be split out (e.g. detailed ownership/integration reference) instead sits inline.	2 / 3
	Total	9 / 12 Passed

Description

100%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong description: third-person voice, concrete capabilities, and an explicit multi-trigger 'Use this skill when' clause that answers both what and when. It is comprehensive without being padded, and occupies a clear niche.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions: 'Coordinate parallel feature development with file ownership strategies, conflict avoidance rules, and integration patterns for multi-agent implementation' names the specific coordination activities rather than vague verbs.	3 / 3
Completeness	Clearly answers both 'what' (coordinate parallel feature development with file ownership/conflict/integration patterns) and 'when' via an explicit 'Use this skill when...' clause enumerating five concrete triggering situations.	3 / 3
Trigger Term Quality	Covers natural terms a user would say — 'decomposing a large feature into independent work streams', 'two or more agents need to implement different layers', 'file ownership', 'interface contracts', 'vertical slices versus horizontal layers' — giving strong coverage of realistic phrasings.	3 / 3
Distinctiveness Conflict Risk	The multi-agent parallel-development niche with file-ownership and interface-contract triggers is distinct and unlikely to fire for unrelated skills; the trigger conditions are specific enough to avoid broad overlap.	3 / 3
	Total	12 / 12 Passed

Validation

87%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 14 / 16 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning
relative_links	Relative link issues: 2 suspicious	Warning

	Total	14 / 16 Passed

Repository: wshobson/agents
Commit: 5cc2549

Reviewed: 5 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.