# 90% of AI Coding Has Been Fixed With This Source: https://www.youtube.com/watch?v=romGzY0Xu0s Recap page: https://rapidrecap.app/video/romGzY0Xu0s Generated: 2026-02-25T14:35:20.456+00:00 --- ## Quick Overview The core of the advancement involves shifting from traditional prompt engineering to context engineering for coding agents, which utilizes a subagent-driven development workflow with strict phase enforcement to ensure systematic progress, leading to the successful implementation of complex features like a Trello-like Kanban board with advanced filtering capabilities. **Key Points:** - The agent workflow employs 'Superpowers'—a set of composable skills—within a subagent-driven development process, structured into sequential phases: Define Tech Stack & Architecture, Set up Project Structure, Implement Core Features, and Write Tests & Deploy (03:54-03:59). - The Trello-like project planning phase involved crucial design decisions, including selecting PostgreSQL (not PGLite) for server-authoritative data storage and adopting a dark-mode-first design philosophy (02:50-02:59). - The implementation phase rigorously followed Test-Driven Development (TDD) principles, where Task 1 (Schema migration + test setup) passed all 4/4 tests before proceeding (06:02-06:13). - The agent identified and fixed two bugs in `app/actions/lists.ts`: one related to silently dropping `state` changes during `updateList` and another where the 'Priority' filter queried the wrong column (`lists.state` instead of `lists.priority`) (08:18-08:24). - Context engineering is contrasted with prompt engineering, showing that for agents, context curation involves feeding the model structured data like memory files, documentation chunks, and message history, rather than just a single system prompt and user message (01:32). - The system enforces adherence to the plan, preventing forward movement until a step is explicitly 'Passed,' ensuring the agent executes the agreed-upon design (03:59). - The agent demonstrated skill invocation, such as using `superpowers:brainstorming` for initial planning and design choices, and later `superpowers:systematic-debugging` when a bug was encountered (02:09, 07:52). ![Screenshot at 03:56: The Superpowers enforcement dashboard visually tracks the agent's progress through four mandatory phases \(Define Tech Stack, Set up Structure, Implement Features, Write Tests\), showing Phase 1 passed, Phase 2 running, and strict adherence to the plan.](https://ss.rapidrecap.app/screens/romGzY0Xu0s/00-03-56.jpg) **Context:** This video details the methodology and execution of 'Superpowers,' an agentic skills framework designed to guide AI coding agents through complex software development tasks systematically. The demonstration focuses on building a Trello-like project management application, highlighting the agent's ability to handle planning, design decisions, implementation via subagents, and systematic debugging, all enforced through a multi-phase workflow. ## Detailed Analysis The video showcases the 'Superpowers' framework, an agentic software development methodology emphasizing structure, testing, and systematic debugging. The process begins with planning, where the user requests a Trello-like app; the agent uses the `brainstorming` skill, leading to architecture decisions like choosing PostgreSQL over PGLite for multi-user support and opting for a dark glassmorphism UI style (02:50-02:59). The agent then generates an 8-step implementation plan, which is enforced via discrete, sequential phases (09:09). Development proceeds using TDD, with Task 1 (Schema migration) passing all tests before moving to Task 2 (Board CRUD) and Task 3 (New components) (06:02-06:42). During development, the agent identifies two critical bugs in `app/actions/lists.ts` that were introduced by a recent diff: one where `updateList` discarded the `state` field, and another where the priority filter queried the wrong database column (08:18). The agent fixes these by correctly destructuring and saving the state and correcting the query to use `lists.priority` (08:25-08:29). After confirming all 24 tests pass, the agent finalizes the implementation, cleans up the worktree, and prepares for merging back to main (05:00-05:14). The video concludes by contrasting this agent-driven context engineering approach with simple prompt engineering, illustrating how agents leverage extensive context (documentation, memory, message history) for complex tasks (01:32). ### Agentic Workflow & Planning - Superpowers enforces a phased, subagent-driven development process (Define Tech Stack, Structure, Implement, Test) - Initial planning involved choosing PostgreSQL for server-authoritative data and dark glassmorphism UI (02:50) - User chose Subagent-Driven execution for fast iteration (04:08) ### Design & Architecture Decisions - For the Trello clone, PGLite was rejected for multi-user apps due to security risks (browser-only access) in favor of PostgreSQL (02:37) - UI/UX planning settled on dark glassmorphism with indigo/violet accents (08:47-09:07) - Filtering was decided to be server-side (Option B) (07:14) ### Implementation & TDD - Development proceeded task-by-task, verifying with TDD; Task 1 (DB setup) passed all 4/4 tests (06:02) - Task 2 (Board CRUD) was intentionally skipped for code quality review to maintain momentum (04:56) ### Debugging and Bug Fixing - Agent systematically debugged data saving issues using `systematic-debugging` skill (07:52) - Two bugs were identified in `app/actions/lists.ts`: state loss in `updateList` and incorrect priority filtering column (08:18) - Fixes involved correcting state destructuring and ensuring priority filters query `lists.priority` (08:25) ### Context Engineering Overview - The agent uses extensive context (System tools, Memory files, Message History) curated via context engineering, unlike simple prompt engineering which relies on a small context window (01:32, 05:17) ### Plugin Usage - The agent registered and installed the `obra/superpowers-marketplace` plugin via command line (01:55-02:07) ![Screenshot at 00:04: A file structure view showing the completion of major development phases \(Phase 3: Frontend Development and Implementation Complete\) documented in markdown files.](https://ss.rapidrecap.app/screens/romGzY0Xu0s/00-00-04.jpg) ![Screenshot at 01:10: A comparison table illustrating the core philosophy of the agent, contrasting common developer 'Thoughts' with the agent's 'Reality' which emphasizes checking skills before action \('This doesn't count as a task' -\> 'Action = task. Check for skills.'\).](https://ss.rapidrecap.app/screens/romGzY0Xu0s/00-01-10.jpg) ![Screenshot at 01:33: The agent displays real-time context usage metrics, showing that 'Messages' consume the largest portion \(59.1%\) of the current Claude Opus 4.5 context window \(185k/200k tokens used\).](https://ss.rapidrecap.app/screens/romGzY0Xu0s/00-01-33.jpg) ![Screenshot at 03:58: The Superpowers enforcement screen shows all four development phases are 'Passed,' indicating the structured workflow completed successfully.](https://ss.rapidrecap.app/screens/romGzY0Xu0s/00-03-58.jpg) ![Screenshot at 08:28: Code comparison view highlighting the fix for Bug 1: state was previously destructured and discarded in updateList \(red line removed\), and the fix correctly includes the rest of the state data \(...rest\) for the DB update \(green line added\).](https://ss.rapidrecap.app/screens/romGzY0Xu0s/00-08-28.jpg)