Skip to main content

Who This Is For

Software Engineers, Data Engineers, DevOps, Security Engineers

Core Scenarios

Scenario 1: Rapid Prototyping (Automatic Acceptance Mode)

Real Case: The product team uses “automatic acceptance mode” to let AI build Vim mode independently, with 70% of the code completed by AI.

How to do it in Happycapy

Ensure you have a clean working directory before starting:
git status  # Confirm there are no uncommitted changes
git checkout -b feature/new-prototype
Describe what you want, not how to build it:
Help me implement a user authentication system:
- Support email + password login
- JWT token authentication
- Include registration, login, and password reset
- Write unit tests
- Run tests continuously during implementation and
  fix errors proactively
  • Happycapy automatically runs tests and fixes errors
  • You focus on the last 20% of core business logic

Best Practices

Suitable For

  • Edge functions
  • Experimental prototypes
  • Unfamiliar technology stacks

Not Suitable For

  • Core business logic
  • Security-critical code
Submit Git checkpoints at each stage to facilitate rollback if needed.

Scenario 2: Debugging Complex Problems

Real Case: The security team reduced incident resolution time from 10-15 minutes to 5 minutes.

How to do it in Happycapy

Provide comprehensive context for faster debugging:
Here is the error I encountered:
[Paste stack trace]

Here is the related documentation:
[Upload or paste docs]

Please help me:
1. Trace the control flow and find the root cause
2. Explain why this error occurs
3. Provide a fix plan and possible side effects

Advantages of Happycapy

Automatic Code Reading

Automatically reads related code files

Stack Understanding

Understands complex call stacks

Runnable Fixes

Provides repair code that can be run directly

Documentation

Generates runbook for future reference
Time savings: 50%

Scenario 3: Test Driven Development (TDD)

Real Case: Inference teams use AI to generate comprehensive unit tests that automatically cover edge cases.

How to do it in Happycapy

Follow the TDD red-green-refactor cycle:
I need to implement a `calculateDiscount(price, userType)` function.

First help me write test cases covering:
- Normal cases (regular user, VIP user)
- Boundary cases (price = 0, negative price, very large amount)
- Exception cases (invalid user type, missing parameters)

Then implement the function and ensure all tests pass.

TDD Workflow

  1. Happycapy writes tests first (TDD red light)
  2. Then writes the implementation (TDD green light)
  3. Automatically runs tests and fixes problems found
  4. You review the code and make final optimizations

Benefits

  • More comprehensive test coverage
  • Reduces missing boundary situations
  • Better code quality

Scenario 4: Quickly Understand Unfamiliar Codebases

Real Case: The API team makes codebase exploration the “first stop”, dramatically reducing context collection time.

How to do it in Happycapy

Ask for a guided tour of the codebase:
I need to fix a login bug, but I am not familiar with
this part of the codebase.

Please help me:
1. Find all files related to user login
2. Explain the key steps of the login flow
3. Identify which files handle authentication, session
   management, and error handling
4. Tell me which files need to be modified if I change
   login logic

What Happycapy Will Do

Architecture Diagram

Generate codebase architecture diagram

Dependencies

Show dependencies between files

Plain Explanations

Explain complex logic in simple language

Precise Locations

Directly locate key lines of code (file.ts:123)
Time Savings: From Hours → Minutes

Scenario 5: Security Review and Infrastructure Changes

Real Case: Security teams use AI to quickly review Terraform plans.

How to do it in Happycapy

First, generate the plan locally:
terraform plan -out=tfplan
terraform show -json tfplan > plan.json
Upload to Happycapy and ask:
Review this Terraform plan and tell me:
1. Which resources will be created/modified/deleted?
2. Are there any security risks?
3. Are there operations that may cause downtime?
4. Will I regret this? 😅

Happycapy Helps You

  • Identify high-risk operations (delete database, modify firewall rules)
  • Check whether permission configuration complies with best practices
  • Generate review checklist
  • Suggest safer alternatives

Developer-Specific Advice

1. Establish a Self-Validation Loop

Create prompts that include automatic validation:
When implementing this feature:
- Run tests automatically after coding
- Run lint checks for code style
- If tests fail, analyze root cause and fix proactively
- Finally return code that passes all tests

2. Develop Intuition for Task Classification

Asynchronous Autonomous
  • Edge functionality
  • Prototypes
  • Unfamiliar technologies
Synchronous Supervision
  • Core business logic
  • Security critical code
  • Production environment

3. Write Clear and Detailed Prompts

  • Give explicit file paths when repositories have similar names
  • State your coding style preference (e.g., “program functionally, avoid classes”)
  • Provide context (e.g., “This project uses TypeScript + React + Zustand”)

4. Use Multiple Instances for Parallel Work

Happycapy supports multiple tabs, each tab is an independent session:
  • One tab handles the frontend, another handles the backend
  • Maintain full context for each session
  • Switching is stress-free

5. Treat Refactoring Like a “Slot Machine”

git commit -m "checkpoint before refactoring"
Let Happycapy work autonomously for 30 minutes
  • If satisfied with the result, accept it
  • If not satisfied, start over:
    git reset --hard HEAD~1
    
Starting over often has a higher success rate than correcting mistakes.

Example Use Cases

Rapid API Endpoint Creation

Create a new REST API endpoint:
- Path: POST /api/users/forgot-password
- Accept email in request body
- Generate secure reset token
- Send email with reset link
- Add rate limiting (5 requests per hour per email)
- Write integration tests
- Update API documentation

Code Quality Improvements

Review and improve the code quality of src/utils/validation.ts:
1. Add TypeScript types for better type safety
2. Add JSDoc comments for public functions
3. Refactor duplicated validation logic
4. Add unit tests for edge cases
5. Ensure consistent error handling

Migration to New Framework

I need to migrate this React class component to a functional
component with hooks:

[Paste component code]

Requirements:
- Convert to functional component with hooks
- Maintain all existing functionality
- Use modern React patterns
- Add TypeScript types
- Keep the same prop interface

Next Steps