Feature Development Workflow

Complete feature lifecycle from planning to deployment using Dotpack’s multi-agent workflows.

Overview

The feature development workflow combines planning, research, implementation, testing, and deployment into a cohesive process using the /build command.

Agents Used:

• Planner: Creates implementation plans.
• Scout: Analyzes codebase context.
• Engineer: Implements code changes.
• QA: Writes and runs tests.
• Reviewer: Checks code quality.

Step-by-Step Guide

1. Planning Phase (/plan)

Before writing code, generate a detailed implementation plan.

/plan "add user authentication with OAuth providers"

What happens:

• Planner creates a detailed implementation plan with phases and success criteria.
• Scout analyzes existing patterns and dependencies.
• Reviewer (optional) can review the plan for architectural soundness.

Output: A detailed markdown plan (e.g., PLAN.md) outlining the strategy.

2. Implementation Phase (/build)

Execute the plan or start a new feature build directly.

/build "implement user authentication based on the plan"

What happens:

• Engineer reads the plan and implements features phase-by-phase.
• Scout provides context on relevant files and existing utilities.
• Skills (Next.js, Tailwind, etc.) are automatically detected to ensure idiomatic code.

Output: Working feature implementation including:

• Backend API endpoints
• Frontend components
• Database schema changes
• Configuration updates

3. Testing Phase (/test)

Verify the new functionality.

/test

What happens:

• QA agent writes and runs comprehensive tests.
• Verifies unit tests, integration tests, and critical paths.
• Reports failures for the Engineer or Debugger to fix.

4. Code Review Phase (/review)

Ensure quality before committing.

/review

What happens:

• Reviewer agent performs security, performance, and style analysis.
• Scans for anti-patterns and potential bugs.
• Generates a report with actionable recommendations.

5. Commit (/commit)

Save your changes with a generated message.

/commit

What happens:

• Generates a professional commit message based on the changes.
• Stages and commits the files.

Real Example

Let’s walk through adding authentication to a Next.js app.

Step 1: Plan

/plan "add user authentication with Better Auth including OAuth providers"

Generated Plan:

• Phase 1: Database setup (users table, sessions)
• Phase 2: Backend API (auth endpoints, middleware)
• Phase 3: Frontend components (login, signup, protected routes)
• Phase 4: OAuth integration (Google, GitHub)

Step 2: Implement

/build

Implementation Details:

• Detects Next.js project → activates Next.js skill.
• Creates API routes: /api/auth/signin, /api/auth/signout.
• Implements middleware for protected routes.
• Builds login/signup forms with proper validation.

Step 3: Test

/test

Test Coverage:

• Unit tests for auth functions.
• Integration tests for API endpoints.
• E2E tests for login/logout flow.

Step 4: Review & Commit

/review
/commit

Best Practices

Before Starting

1. Clear Requirements: Have specific acceptance criteria in your prompt.
2. Context: Use /scout if you are unsure about existing patterns.

During Implementation

1. Iterate: Use /fix if a specific part of the build fails or needs adjustment.
2. Validate: Run /test frequently.

Finalizing

1. Security: Always run /review for sensitive features like auth.
2. Docs: Use /docs to update project documentation with the new feature.