How I Built a 13-Agent Claude Skill That Dominates Competitive Coding Challenges

The Problem:

I participate in competitive coding challenges across platforms — Kaggle, hackathons, Codeforces, DevPost buildathons, AI/ML competitions. Every time, I noticed the same pattern:

I'd jump straight into coding without fully parsing the scoring rubric I'd forget edge cases that cost me points I'd run out of time because I optimized the wrong things My submissions lacked documentation, tests, and polish that judges notice In long Claude sessions, context compaction would make Claude forget key decisions mid-competition

The real insight: winning competitions isn't about writing the cleverest algorithm. It's about covering every angle — product thinking, architecture, testing, security, documentation — like a real team would.

The Solution:

I built Competitive Dominator — a Claude Skill that deploys a virtual team of 13 specialized agents to attack challenges from every perspective.

How It Works:

When you tell Claude about a competition, the skill kicks off a 6-phase pipeline: Phase 0 — Intelligence Gathering: Parses the challenge spec word-by-word. Extracts scoring criteria, constraints, input/output formats, and hidden requirements. Creates a Challenge State Document (more on this below). Phase 1 — Deploy Agent Team: Based on challenge type, activates the right specialists:

Chief Product Manager — owns the scoring rubric, prioritizes by points-per-effort Solution Architect — picks algorithms, analyzes complexity, designs the structure Lead Developer — writes clean, idiomatic, documented code Test Engineer — TDD, edge cases, stress tests, fuzzing Code Reviewer — catches bugs, performance issues, scoring alignment gaps Data Scientist — activated for ML/data challenges (feature engineering, ensembling, CV strategy) ML Engineer — training pipelines, LLM integration, reproducibility Plus: Performance Engineer, Security Auditor, DevOps, Technical Writer, UX Designer, Risk Manager

Phase 2 — Architecture: Design before code. Complexity analysis, module structure, API contracts, optimization roadmap (V1 → V2 → V3).

Phase 3 — Implementation: Test-Driven Development. Tests written before code. Every module tested after implementation. Output format validated character-by-character.

Phase 4 — Optimization Loop: Self-evaluates the solution against every scoring criterion using a built-in scoring engine. Produces a gap analysis ranked by ROI (points × probability / effort). Closes gaps in priority order.

Phase 5 — Submission Prep: Final review circuit by all agents. Platform-specific submission checklist. Packaging, format verification, documentation.

The Memory Problem (And How I Solved It):

The biggest challenge building long competition solutions with Claude is context loss. During compaction, Claude forgets key decisions, constraints, even what the challenge is about. The solution: a Challenge State Document (CHALLENGE_STATE.md) that acts as a living single source of truth. It tracks the challenge spec, scoring criteria, agent assignments, every decision with reasoning, and current progress. Claude reads this file to recover full context after any compaction. There's a Python script (challenge_state.py) that manages this document programmatically — initialize, update status, log decisions, add agent assignments.

The Self-Evaluation Engine:

Most competitors don't score themselves before submitting. The built-in self_eval.py script produces a gap analysis table: Criterion Weight Score Max Gap Effort Priority Correctness 40.0 35.0 40.0 5.0 medium 100.0 Code Quality 15.0 10.0 15.0 5.0 low 75.0 Performance 20.0 15.0 20.0 5.0 high 25.0 Priority = (weight × gap) / effort. So you always work on the highest-ROI improvement first.

What I Built (Architecture):

competitive-dominator/ ├── SKILL.md — Main skill (Claude reads this first) ├── INSTALL.md — 5 installation methods ├── README.md, LICENSE, etc. — GitHub-ready ├── agents/ — 8 agent role definitions │ ├── chief-product-manager.md │ ├── solution-architect.md │ ├── lead-developer.md │ ├── test-engineer.md │ ├── code-reviewer.md │ ├── data-scientist.md │ ├── ml-engineer.md │ └── conditional-agents.md — 6 more agents in one file ├── references/ — Deep playbooks (loaded on demand) │ ├── challenge-taxonomy.md — 6 challenge categories │ ├── ml-playbook.md — ML competition winning framework │ ├── web-playbook.md — Hackathon speed architecture │ └── submission-checklist.md — Platform-specific verification └── scripts/ — Zero-dependency Python tools ├── challenge_state.py — State document manager └── self_eval.py — Gap analysis scoring engine The skill uses progressive disclosure — Claude only loads what's needed. The main SKILL.md is always loaded (~200 lines). Agent files load based on challenge type. Reference playbooks load only for specific categories. This keeps context lean while having deep expertise available.

Tech Stack:

Claude.ai — entire skill authored in a single session Markdown — all instructions and agent definitions Python — utility scripts (zero external dependencies, stdlib only) Git/GitHub — version control and distribution

No frameworks. No npm packages. No build step. Just markdown files that Claude reads and Python scripts that Claude runs.

Hard-Won Lessons:

1. Treat the scoring rubric like a product spec. Most competitors read the problem statement but skim the evaluation criteria. The CPM agent forces you to map every line of code to specific points on the board.
2. TDD works in competitions too. Writing tests first catches output format mismatches early. I've seen submissions score zero because of a trailing newline. The Test Engineer agent prevents this.
3. Context compaction is the real enemy in long sessions. The Challenge State Document pattern is the single most important feature. Without it, Claude loses track of constraints and makes decisions that contradict earlier ones.
4. Progressive disclosure matters for skills. My first draft put everything in SKILL.md — 800+ lines. Claude would waste tokens reading ML playbook content for a simple algorithmic challenge. Splitting into on-demand references cut unnecessary context by ~60%.
5. Self-evaluation before submission is a cheat code. Most people submit and hope. Scoring yourself against the rubric first, then fixing the highest-ROI gaps, consistently improves placement.

What's Next:

Adding more platform-specific agents (Kaggle notebook agent, Codeforces fast I/O agent) Building a competition history tracker that learns from past submissions Creating a prompt-based "challenge simulator" for practice Integrating with the Claude Code plugin marketplace when available

Links:

GitHub: https://github.com/ankitjha67/competitive-dominator License: MIT (free to use, modify, distribute) Install: cp -r competitive-dominator ~/.claude/skills/user/competitive-dominator