CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

multi-ai-implementation

Production-ready code generation and incremental development using Explore-Plan-Code-Commit workflow. TDD-driven with <200 line changes, automatic rollback, and multi-agent coordination. Use when implementing features, refactoring code, migrating systems, or integrating components requiring rigorous testing and quality assurance.

Quality

72%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./.claude/skills/multi-ai-implementation/SKILL.md

The canonical home for this skill is multi-ai-implementation in fernandezbaptiste/Skrillz

SKILL.md
Quality
Evals
Security

Quality

Content

51%Weight 40%Scale 1-5

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

The content's greatest strength is its exceptionally clear 6-step workflow with per-step validation checklists and well-designed feedback loops (doom-loop prevention, TCR rollback, quality-gate iteration). Its weaknesses are severe token inefficiency — ~1,200 lines with duplicated sections, teaching of basic concepts, and marketing-style claims ("Quality Guarantee... achieves ≥85/100") — and poor bundle hygiene: appendices inlined instead of split into reference files, references to nonexistent directories, and an unreferenced bundled script.

Suggestions

Cut the body to roughly 300-400 lines: delete the Prerequisites 'Understanding' list and 'Common Mistakes' sections (Claude already knows TDD and git basics, and Mistakes just inverts Best Practices), and merge Appendix B into Step 3 where doom-loop prevention is already described.

Move Appendix A (coordination patterns) and Appendix C (tooling per language, rollback strategy, cost controls) into separate reference files (e.g., references/coordination-patterns.md, references/tooling.md) and link to them one level deep; fix or remove the references to nonexistent examples/ and schemas/ directories.

Reference the bundled scripts/pre-flight-check.sh from the body (e.g., as a Step 0 prerequisite check) so it is discoverable, and replace placeholder templates like '[What exists now]' and 'Task [X]' with one concrete worked example.

DimensionReasoningScore

Conciseness

The ~1,200-line body is noticeably verbose with many padded sections: it explains concepts Claude already knows ("Basic TDD concepts (test-first development)", "Git workflow (commits, branches, rollback)", per-language tooling lists like "Linter: ESLint / Type checker: tsc"), duplicates doom-loop prevention in both Step 3 and Appendix B, and restates Best Practices inverted as "Common Mistakes". This matches anchor 2 (several unnecessary explanations or padded sections); it is not a 1 because the core steps do contain genuinely useful, non-obvious content, and not a 3 because the padding is extensive rather than incidental.

2 / 5

Actionability

There is real concrete guidance ("npm test || git reset --hard HEAD~1", full git commit and gh pr create commands, 3-level Glob/Grep/Read discovery examples), but much of the guidance is placeholder-laden templates ([What exists now], "Task [X]") or illustrative pseudocode — the task({...}) TypeScript blocks are not real invocations of the Task tool, and the core mechanics of Steps 2, 3, and 6 delegate to sibling skills (multi-ai-planning, multi-ai-testing, multi-ai-verification) that are not shown to exist. This lands at anchor 3: some concrete, executable guidance but incomplete, with pseudocode and missing key details.

3 / 5

Workflow Clarity

The 6-step workflow is clearly sequenced, and every step has a uniform Purpose/Inputs/Process/Outputs structure plus an explicit Validation checklist ("[ ] Coverage meets gate (≥80%)") and a Next pointer. Error-recovery feedback loops are explicit: the max-3-attempt iteration loop, doom-loop detection with escalation to a human, "If Quality <90: Iterate" gap analysis, and commit-only-if-all-gates-pass. This matches anchor 5 (clear sequence, explicit validation steps, feedback loops, checklists).

5 / 5

Progressive Disclosure

The body is a monolithic ~1,200-line file whose appendices (Task-tool coordination patterns, doom-loop prevention, per-language tooling) clearly belong in separate reference files, matching anchor 2 (content that belongs in separate files is inlined). Compounding this, it points to "examples/" and "JSON schemas (in schemas/)" which do not exist in the bundle, while the one bundled script (scripts/pre-flight-check.sh) is never referenced from the body — a buried reference. It is not a 1 because section headers and the Quick Reference table do provide navigable structure.

2 / 5

Total

12

/

20

Passed

Description

83%Weight 40%Scale 1-5

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 that clearly and explicitly states both what the skill does and when to use it, with mostly concrete mechanisms (TDD, <200-line increments, automatic rollback, multi-agent coordination) and natural trigger phrases. Its only weaknesses are minor: light buzzword usage ("production-ready", "rigorous") and a few missing natural trigger synonyms.

DimensionReasoningScore

Specificity

The description lists several concrete actions and mechanisms — "code generation and incremental development using Explore-Plan-Code-Commit workflow", "TDD-driven with <200 line changes, automatic rollback, and multi-agent coordination" — which matches the anchor for several specific actions with minor gaps. It falls short of anchor 5 because "production-ready code generation" is partially buzzword and the full action set (testing, verification, quality gates) is only implied via 'TDD-driven'; it clearly exceeds anchor 3, which expects only 1-2 concrete actions.

4 / 5

Completeness

It explicitly answers both questions: what ("Production-ready code generation and incremental development using Explore-Plan-Code-Commit workflow. TDD-driven with <200 line changes, automatic rollback, and multi-agent coordination") and when ("Use when implementing features, refactoring code, migrating systems, or integrating components") with concrete trigger phrases, matching anchor 5 exactly. The 'Use when...' clause is present and specific, so no cap applies.

5 / 5

Trigger Term Quality

"Use when implementing features, refactoring code, migrating systems, or integrating components" provides good keyword coverage of natural phrases users would say ("implement a feature", "refactor code", "migrate", "integrate"). It sits at anchor 4 rather than 5 because common variations like "building", "adding a feature", "writing tests first", or language-specific terms are missing.

4 / 5

Distinctiveness Conflict Risk

The named Explore-Plan-Code-Commit workflow, TDD emphasis, <200-line increment rule, and rollback mechanics give it a recognizable niche distinct from companion planning/testing/verification skills. It stays at anchor 4 rather than 5 because broad triggers like "implementing features" and "refactoring code" overlap with general coding-assistant skills, creating minor conflict risk.

4 / 5

Total

17

/

20

Passed

Validation

87%

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

CriteriaDescriptionResult

skill_md_line_count

SKILL.md is long (1204 lines); consider splitting into references/ and linking

Warning

allowed_tools_field

'allowed-tools' contains unusual tool name(s)

Warning

Total

14

/

16

Passed

Repository

fernandezbaptiste/Skrillz

Path

.claude/skills/multi-ai-implementation/SKILL.md

Reviewed

Table of Contents

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.