February 16, 2026
Task decomposition is the bottleneck of AI-driven development. Give an agent a vague plan and it writes vague code. Give it a precise, well-scoped subtask and it performs like a senior engineer.
The task: replicate the functionality of an existing HTTPS Security Checker service — take a working product, write a detailed spec describing what it does, and hand that spec to five different AI models to decompose into implementable subtasks.
We scored their decomposition plans across 17 criteria. The results reveal two fundamentally different philosophies for AI-assisted development.
We took an existing HTTPS Security Checker service and reverse-engineered a detailed product spec from it: TLS configuration analysis, certificate health, security headers, HSTS, DNS security, HTTP/3 support, mixed content detection, and HTTPS redirect validation. The spec included 8 check modules, a grading system, export capabilities, and deployment requirements.
Each model produced a full task decomposition plan — a DAG of subtasks with dependencies, file lists, and acceptance criteria.
| Model | Agent | Plan Size | Subtask Count | Time | Cost |
|---|---|---|---|---|---|
| GPT-5.3 | Copilot CLI | ~44 KB | 19 | ~6 min | Paid |
| Claude Opus | Claude Code | ~110 KB | 15 | ~13 min | Paid |
| Kimi | Kilocode | ~65 KB | 20 | 6 min 12 sec | $0.46 |
| GLM-5 | Kilocode | ~206 KB | 16 | 26 min 14 sec | Free |
| MiniMax-25 | Kilocode | ~15 KB | 16 | ~3 min | Free |
Opus clocked in at ~13 minutes but ran a swarm of subagents in parallel. GLM-5 and MiniMax-25 were free-tier models run through Kilocode. Kimi cost just $0.46 for a top-3 result. Codex via Copilot CLI finished in about 6 minutes — comparable to Kimi despite the paid tier.
We evaluated each plan across 17 criteria grouped into 7 weighted categories:
| Category | Weight | What We Measured |
|---|---|---|
| Decomposition quality | 20% | Granularity, DAG correctness, one-concern-per-task adherence |
| File and criteria explicitness | 20% | File path coverage, acceptance criteria quality |
| Implementation guidance | 20% | Code examples, test strategy, practical implementability |
| Spec compliance | 15% | Coverage of all 8 check modules |
| Security and robustness | 10% | Error handling, SSRF defense, rate limiting |
| Frontend and export | 10% | UI coverage, PDF/JSON/CSV export detail |
| DevOps and deployment | 5% | Docker, cleanup cron, production config |
Each criterion scored 1-10, then weighted into a final score.
| Rank | Model | Score | Philosophy |
|---|---|---|---|
| 1 | Codex / GPT-5.3 | 8.77 | Directive — zero code, maximum structure |
| 2 | Claude Opus | 8.45 | Implementation-heavy — 33 code blocks |
| 3 | Kimi | 8.43 | Balanced — structure meets detail |
| 4 | GLM-5 | 8.30 | Code-rich — 206 KB of guidance |
| 5 | MiniMax-25 | 5.13 | Skeletal — insufficient for handoff |
Codex produced the most disciplined plan. Every one of its 19 tasks covers exactly one concern. File paths are fully specified (127+ files), and each task includes 3 runnable verification commands (typecheck, test, grep). The repository abstraction constraint is repeated verbatim in every single task.
The trade-off: zero TypeScript code blocks. The plan is purely directive — it tells the implementing agent what to build, not how. No Docker/deployment task, no CI/CD pipeline.
Opus took the opposite approach: 33 TypeScript code blocks with near-complete implementations. A developer could start coding immediately. It includes 80+ specific test cases, a comprehensive Docker task, and detailed grade calculator logic.
The trade-off: only 15 tasks. Five check modules are merged into just 2 tasks, violating the one-concern-per-subtask rule. At 7.3 KB per task, some subtasks may exceed optimal context windows for agent prompts.
Kimi hit the sweet spot between structure and detail with 20 well-scoped tasks. It follows the one-concern rule faithfully, provides interface signatures, and includes real-world test domains (badssl.com). Slightly less implementation detail than Opus or GLM, but more architecturally rigorous.
GLM produced the largest output at 206 KB — an engineer could start coding from the TypeBox schemas and patterns alone. But it merges HTTP/3 and Mixed Content into one task, stuffs too much into the API server task (10+ files), and marks PDF export as TODO.
At 0.9 KB per task, MiniMax's plans are skeletons. No code examples, no executable acceptance criteria, incomplete file lists. An implementer would essentially need to re-derive the spec.
The top two plans represent fundamentally different design philosophies:
| Dimension | Codex / GPT-5.3 | Claude Opus |
|---|---|---|
| Philosophy | Maximally directive, zero code | Maximally detailed, near-complete code |
| Task count | 19 (one concern each) | 15 (some multi-concern) |
| Size | 44 KB (~2.3 KB/task) | 110 KB (~7.3 KB/task) |
| TypeScript code blocks | 0 | 33 |
| Best for | AI agents that generate code from specs | Developers who want to copy-paste and adapt |
| Verification | 3 runnable commands per task | 11 testable criteria per task |
| One-concern rule | Perfect adherence | 5 modules merged into 2 tasks |
| Docker/deploy | Weak | Comprehensive |
No plan — from any model — covered these:
For AI-agent-driven workflows (Codex, Claude Code, Cursor): Use Codex-style plans. Strict isolation, verbatim constraints, and verification commands are optimized for autonomous agents that generate their own code.
For human developers: Use Opus-style plans. The 33 code blocks and detailed specifications minimize ambiguity and allow direct implementation.
For a hybrid approach: Take Codex's 19-task DAG as the project structure, inject Opus's code blocks and test cases into each task, add Kimi's real-world test domains for acceptance criteria, and fill the gaps all plans missed (caching, CI/CD, OpenAPI).
The best decomposition depends on who — or what — is implementing it. Structure your plans for your executor.
Building AI-agent workflows? Get notified about VibeCoder Heretic updates.
Announcing VibeCoder Heretic, an autonomous coding agent boilerplate that runs on your infrastructure. Full workflow with PRs, Kanban boards, and real-time visibility.