User-Testable Implementation Phases
Turn large features into small, reviewable implementation phases with concrete user tests, dependencies, and scope cuts.
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
Your feature plan becomes one huge PR, or its first three milestones deliver infrastructure nobody can try. This skill breaks the feature into small working slices, each with a concrete user action, an expected result, and a review boundary.
What it does
- Splits features by usable behavior instead of database, API, and frontend layers.
- Defines exact manual tests, including persistence, permissions, and relevant failure cases.
- Exposes hidden dependencies, simulated behavior, and prerequisites before they become surprises.
- Checks whether each phase fits a focused review and splits overloaded phases again.
- Identifies useful stopping points and deferrable scope when the deadline is tight.
- Reworks existing plans without turning a quick boundary question into a full specification.
What you get
A sequenced implementation plan with user-visible outcomes, included and excluded work, dependencies, acceptance checks, and merge or rollout conditions. Estimates distinguish evidence from assumptions, and unresolved decisions identify exactly which phase they block.
Best for
Developers, engineering leads, and product owners reviewing AI-generated code or delivering large features to stakeholders who need to try progress incrementally.
SKILL.md preview
---
name: user-testable-implementation-phases
description: >-
Break large feature requests and oversized implementation plans into reviewable vertical slices, each with a user-observable outcome, concrete acceptance checks, explicit dependencies, and a safe stopping point. Use when the user says "break this into phases", "make this feature independently testable", "this PR is too big to review", "my AI keeps dumping the whole feature at once", "split this plan into smaller deliveries", "what can we ship first?", or "can the client test each milestone?".
---
# User-Testable Implementation Phases
… (sign up to view the full skill)More development skills
View all Development skills →Performance Bottleneck Profiling: Node, Python, Go
Classifies a slowdown, gives exact profiler commands, reads the output, and proves the fix with same-conditions p95/p99 numbers.
Feature Scaffolding with Working Tests
Turn a short feature spec into code, runnable tests, and integration wiring that match your existing project.
Feature Flag Rollouts and Kill Switches
Design staged flag rollouts, verify rollback paths, and audit flag debt with explicit defaults, gates, and retirement plans.
Microcontroller Firmware and RTOS Engineering
Build and debug MCU firmware with bounded ISR/RTOS timing, safe DMA ownership, and measured power budgets.