AI Skills Deep Dive: How Craft's Claude Integration Works

Craft includes 16 specialized AI skills that integrate directly with Claude Code. These aren't just code generators - they're intelligent assistants that understand your project's architecture, quality level, and best practices.

What Are AI Skills?

AI Skills are specialized prompts and workflows designed to handle specific development tasks. When you activate a skill in Claude Code, it:

1. Analyzes your project structure
2. Detects your quality level (Rapid, Balanced, or Crafted)
3. Applies the appropriate architectural patterns
4. Generates code that matches your project's conventions
5. Creates tests alongside the implementation
6. Validates the output against quality rules

The 16 Skills Breakdown

Craft organizes skills into three categories: Agent Skills, Level Skills, and Workflow Skills.

1. Agent Skills (6 total)

These are role-based assistants that specialize in different aspects of development:

Architect Skill

The Architect skill helps you design system architecture and make technical decisions. Use it when you're planning:

• Database schema changes
• API endpoint structure
• New feature integration
• Performance optimizations

Example prompt: "I need to add real-time notifications. Should I use WebSockets or Server-Sent Events?"

The Architect will analyze your stack (Next.js, tRPC) and recommend the best approach with pros/cons.

Developer Skill

The Developer skill is your go-to for implementing features. It generates:

• tRPC routes and procedures
• React components
• Database queries with Prisma
• Form validation with Zod

Example prompt: "Add a feature where users can export their data as CSV."

The Developer will create the export API endpoint, add a button to the UI, and handle the file download.

Tester Skill

The Tester skill generates comprehensive test suites. It creates:

• Unit tests for services and utilities
• Integration tests for API routes
• E2E tests for user flows
• Mock data and fixtures

Example prompt: "Generate tests for the user profile update feature."

The Tester will write tests covering success cases, validation errors, and edge cases.

Reviewer Skill

The Reviewer skill performs automated code reviews. It checks for:

• Code quality issues
• Security vulnerabilities
• Performance problems
• Architecture violations

Example prompt: "Review the payment processing code for security issues."

The Reviewer will flag potential SQL injection risks, insecure API calls, and suggest fixes.

Designer Skill

The Designer skill helps with UI/UX implementation. It can:

• Generate component variants
• Suggest layout improvements
• Ensure accessibility compliance
• Implement responsive designs

Example prompt: "Make this form more user-friendly and add proper error states."

Marketing Skill

The Marketing skill assists with customer-facing content:

• Landing page copy
• Email templates
• Error messages
• Onboarding flows

2. Level Skills (3 total)

These skills enforce the quality standards for each level:

Rapid Skill

Optimizes for speed. Generates flat architecture with minimal abstraction.

• Max 100 lines per function
• Logic in tRPC routers
• Basic validation
• Minimal tests

Balanced Skill

Balances speed and maintainability. Enforces 3-layer architecture.

• Max 50 lines per function
• Routers → Services → Repositories
• SOLID principles
• 70% test coverage

Crafted Skill

Maximizes long-term quality. Implements hexagonal architecture.

• Max 20 lines per function
• Domain → Application → Infrastructure
• DDD patterns
• 100% domain coverage

3. Workflow Skills (4 total)

These are end-to-end workflows for common tasks:

Feature Workflow

Complete feature implementation from architecture to deployment:

1. Architect designs the feature
2. Developer implements it
3. Tester writes tests
4. Reviewer validates code quality

Bugfix Workflow

Systematic bug resolution:

1. Reproduce the bug
2. Write a failing test
3. Fix the implementation
4. Verify all tests pass

Refactor Workflow

Safe refactoring with continuous verification:

1. Ensure tests exist
2. Make incremental changes
3. Run tests after each change
4. Validate architecture rules

Security Workflow

Security audit and hardening:

1. Scan for vulnerabilities
2. Check authentication/authorization
3. Validate input sanitization
4. Review dependencies

How Skills Adapt to Quality Levels

Here's the magic: the same skill behaves differently based on your quality level.

Example: Adding User Search

Rapid level:

• Adds search logic directly in the tRPC router
• Simple text matching with Prisma
• Basic input validation
• One integration test

Balanced level:

• Creates a SearchService in the service layer
• Adds filtering and pagination
• Zod schemas for query validation
• Unit tests for SearchService + integration tests for API

Crafted level:

• Defines a SearchUseCase in the application layer
• Uses repository pattern for data access
• Implements specification pattern for complex queries
• 100% test coverage including edge cases

Same prompt, three different implementations - each optimized for its context.

Real-World Example: Payment Integration

Let's walk through using the Feature Workflow to add Stripe subscriptions:

1. Step 1: Activate the Feature Workflow in Claude Code
2. Step 2: Describe the feature: "Add monthly and yearly subscription plans with Stripe."
3. Step 3: The Architect analyzes the requirement and proposes:
   • Database schema changes (add subscription table)
   • Stripe webhook integration
   • Customer portal link
4. Step 4: The Developer implements:
   • Prisma schema updates
   • tRPC routes for checkout
   • Webhook handler
   • Customer portal route
5. Step 5: The Tester generates:
   • Unit tests for webhook handlers
   • Integration tests mocking Stripe API
   • E2E test for checkout flow
6. Step 6: The Reviewer checks:
   • Webhook signature verification
   • Idempotency handling
   • Error recovery

Total time: ~30 minutes. Without AI skills, this would take 4-6 hours.

Best Practices for Using Skills

1. Be specific in your prompts. Instead of "add auth," say "add email/password authentication with email verification."
2. Use workflows for complex features. Workflows orchestrate multiple skills in the right order.
3. Review the generated code. AI skills are very good, but always review before committing.
4. Let skills choose the quality level. They auto-detect your level, but you can override if needed.
5. Iterate incrementally. Start with the Developer skill, then use Reviewer to improve.

Limitations and Gotchas

AI skills are powerful, but they're not magic:

• They need context. Make sure your project structure is clean and follows conventions.
• They can't read your mind. Vague prompts produce vague results.
• They don't know your business logic. You'll need to explain domain-specific requirements.
• They can make mistakes. Always review generated code, especially for security-critical features.

The Bottom Line

Craft's AI skills are like having a senior developer pair programming with you 24/7. They know the codebase, follow best practices, write tests, and adapt to your quality standards.

For solo founders and small teams, this is a game-changer. You ship 5-10x faster without sacrificing code quality.