designing-and-implementing
Use when receiving feature requests, architectural discussions, or multi-step implementation needs that require design before coding.
Best use case
designing-and-implementing is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when receiving feature requests, architectural discussions, or multi-step implementation needs that require design before coding.
Teams using designing-and-implementing should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/designing-and-implementing/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How designing-and-implementing Compares
| Feature / Agent | designing-and-implementing | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when receiving feature requests, architectural discussions, or multi-step implementation needs that require design before coding.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Design → Plan → Implement ## When to Use This Flow Check if planning is needed: ```bash bpsai-pair intent should-plan "user's request here" ``` Get flow recommendation: ```bash bpsai-pair intent suggest-flow "user's request here" ``` Use this flow for: features, refactors, multi-step work. Skip planning for: typo fixes, small bugs, documentation tweaks. ## Workflow ### 1. Clarify Requirements - Restate the goal in 1-3 sentences - Identify affected components - Ask clarifying questions if ambiguous - Research existing code patterns ### 2. Propose Approaches Present 2-3 options with pros/cons and recommend one. ### 3. Create Plan ```bash bpsai-pair plan new <slug> --type feature --title "Title" ``` ### 4. Add Tasks Task format in `.paircoder/tasks/`: ```yaml --- id: TASK-XXX title: Task title status: pending priority: P0 # P0=must, P1=should, P2=nice complexity: 30 # 10-100 scale --- ## Objective What this accomplishes. ## Acceptance Criteria - [ ] Criterion 1 - [ ] Tests pass ## Dependencies - Requires TASK-YYY (if any) ``` ### 5. Sync to Trello ```bash bpsai-pair plan sync-trello <plan-id> --target-list "Planned/Ready" ``` ### 6. Implement Each Task 1. `bpsai-pair task update TASK-XXX --status in_progress` 2. Write tests first (see implementing-with-tdd skill) 3. Implement feature 4. Complete via managing-task-lifecycle skill ## Key Files - Plans: `.paircoder/plans/` - Tasks: `.paircoder/tasks/` - State: `.paircoder/context/state.md` - Project context: `.paircoder/context/project.md` ## Commands ```bash bpsai-pair plan list # List plans bpsai-pair plan show <id> # Show plan details bpsai-pair task list --plan <id> # Tasks in plan bpsai-pair task next # Next task to work on ```
Related Skills
implementing-real-user-monitoring
This skill assists in implementing Real User Monitoring (RUM) to capture and analyze actual user performance data. It helps set up tracking for key metrics like Core Web Vitals, page load times, and custom performance events. Use this skill when the user asks to "setup RUM", "implement real user monitoring", "track user experience", or needs assistance with "performance monitoring". It guides the user through choosing a RUM platform, designing an instrumentation strategy, and implementing the necessary tracking code.
implementing-database-caching
Process use when you need to implement multi-tier caching to improve database performance. This skill sets up Redis, in-memory caching, and CDN layers to reduce database load. Trigger with phrases like "implement database caching", "add Redis cache layer", "improve query performance with caching", or "reduce database load".
implementing-database-audit-logging
Process use when you need to track database changes for compliance and security monitoring. This skill implements audit logging using triggers, application-level logging, CDC, or native logs. Trigger with phrases like "implement database audit logging", "add audit trails", "track database changes", or "monitor database activity for compliance".
implementing-backup-strategies
Execute use when you need to work with backup and recovery. This skill provides backup automation and disaster recovery with comprehensive guidance and automation. Trigger with phrases like "create backups", "automate backups", or "implement disaster recovery".
designing-database-schemas
Process use when you need to work with database schema design. This skill provides schema design and migrations with comprehensive guidance and automation. Trigger with phrases like "design schema", "create migration", or "model database".
designing-components
Use this skill when you need to design a component
designing-frontend
Build distinctive, production-grade frontend interfaces with memorable aesthetics. Use when creating web components, pages, or applications. Prioritizes creative, context-specific design over generic patterns.
implementing-with-tdd
Use when implementing bug fixes, features, or any code changes where test-first development is appropriate.
implementing-command-palettes
Use when building Cmd+K command palettes in React - covers keyboard navigation with arrow keys, keeping selected items in view with scrollIntoView, filtering with shortcut matching, and preventing infinite re-renders from reference instability
implementing-code
Implements code changes and creates commits. Triggered when: implementation tasks, code changes, feature additions, bug fixes.
designing-tests
Designs and implements testing strategies for any codebase. Use when adding tests, improving coverage, setting up testing infrastructure, debugging test failures, or when asked about unit tests, integration tests, or E2E testing.
designing-architecture
Designs software architecture and selects appropriate patterns for projects. Use when designing systems, choosing architecture patterns, structuring projects, making technical decisions, or when asked about microservices, monoliths, or architectural approaches.