Phased Plan
Forces any implementation plan to be broken into small, individually user-testable phases so large features never turn into unreviewable PRs.
Before & after
Same prompt, same agent — the only difference is the skill.
Building a real-time comment system is definitely doable. You'll need to think about the backend infrastructure for handling real-time updates, the frontend UI components, and the database schema to store comments. I could outline a general architecture, but it would help to know more about your scale requirements and whether you're using specific frameworks. I'd recommend starting with a basic implementation and then adding features incrementally. Would you like me to suggest some technologies you could use?
PHASE 1: Backend WebSocket Infrastructure (1 day, user-testable)
- Implement WebSocket server (Node.js, Socket.IO)
- Add comment schema to database
- Test: User opens page, server broadcasts test message to console
- Deliverable: POST /api/comments returns { id, text, createdAt }
PHASE 2: Frontend Comment Display (1 day, user-testable)
- Build comment list component showing static hardcoded comments
- Add 'View Comments' toggle on any page
- Test: User clicks button, sees 3 sample comments rendered
- Deliverable: Comments UI visible and styled
PHASE 3: Real-time Sync (1.5 days, user-testable)
- Connect frontend to WebSocket
- Listen for 'comment:new' and 'comment:deleted' events
- Test: User posts comment in one tab, it appears immediately in another tab
- Deliverable: Two users in different browsers see live updates
PHASE 4: Permissions + Moderation (1 day, user-testable)
- Add role-based delete permissions
- Implement soft-delete for moderation workflow
- Test: Admin can delete, regular user cannot
- Deliverable: Edit/delete buttons appear for authorized users only
PHASE 5: Performance + Pagination (0.5 day, user-testable)
- Infinite scroll or cursor pagination
- Load only last 50 comments on page load
- Test: Page loads fast even on 10K-comment threads
Each phase is independently reviewable and user-demable before proceeding.About this skill
name: phased-plan description: Use when Forces any implementation plan to be broken into small, individually user-testable phases so large features never turn into unreviewable PRs.
Phased Plan
Similar to standard plan-mode features in Claude Code and Codex, but Phased Plan specifically chunks each plan into small feature groupings that are each independently testable by the client — not purely backend or purely frontend, but a slice a user can actually try. Built to solve the problem of reviewing 2,000-line AI-generated PRs, which the creator says is nearly impossible to review thoroughly and honestly.
What you get
- Automatic phase-based plan structuring, each phase independently client-testable, dramatically smaller reviewable PR chunks, pairs with Grill Me for full up-front clarity.
Customize your output
- Define how granular each phase should be and whether phases must always include a testable UI component.
Example output
A large AI UGC studio feature was broken into 8 testable phases instead of one giant implementation, each independently reviewable.
Best for
Developers and engineering leads who need to review AI-generated code without wading through thousands of lines in a single PR.
SKILL.md preview
---
name: phased-plan
description: Use when a feature request is large enough that a single implementation plan would produce an unreviewable pull request, and it needs breaking into independently testable phases instead.
version: 1.0.0
category: Development / Planning
author: AgentVolt
license: proprietary
tags:
- development
- planning
- standard
---
# Phased Plan
Breaks any implementation plan into small phases a client can actually try end to end, instead of one plan that becomes an unreviewable diff.
## When to use
… (sign up to view the full skill)