1. Idea → 2. Spec → 3. Implement → 4. Test → 5. Deploy

# Trong Kiro Chat
"Tạo spec cho feature: User profile management
- Users can update profile info
- Upload avatar image
- Change password
- View activity history"

Kiro: *Creates spec with requirements, design, tasks*
You: *Review and refine*

Click "Start Tasks" → Kiro implements all

- Let Kiro do: Boilerplate, CRUD, tests
- You do: Complex business logic, algorithms

# Auto-run with hooks
Save file → Hook triggers → Tests run

# Or manual
npm test

git add .
git commit -m "feat: add user profile management"
git push

1. Planning → 2. Spec Review → 3. Implementation → 4. Code Review → 5. Merge

"Chúng ta cần feature user notifications"

"Tôi sẽ tạo spec và share với team"

# Trong Kiro
"Tạo spec cho notification system:
- Email notifications
- In-app notifications
- Push notifications
- Notification preferences"

1. Tech Lead share spec trong Git
2. Team members review requirements.md
3. Discuss và refine trong meeting
4. Update spec based on feedback
5. Approve spec

1. Checkout feature branch
2. Implement assigned tasks với Kiro
3. Run tests
4. Commit changes
5. Create Pull Request

1. Read spec để hiểu context
2. Review code changes
3. Check tests
4. Verify requirements met
5. Approve hoặc request changes

1. Merge PR
2. CI/CD runs tests
3. Deploy to staging
4. QA testing
5. Deploy to production

1. Create Spec
2. Review Requirements
3. Design Architecture
4. Break Down Tasks
5. Implement
6. Test
7. Document
8. Deploy

"Tạo spec cho search feature:
- Full-text search
- Filter by category
- Sort results
- Pagination
- Search suggestions"

Use Kiro Autopilot or manual implementation

1. Reproduce Bug → 2. Understand Root Cause → 3. Fix → 4. Test → 5. Deploy

# Trong chat
"#Problems
Bug: Users can't login with email containing uppercase letters

Steps to reproduce:
1. Register with Test@Example.com
2. Try login with test@example.com
3. Login fails"

"Analyze AuthService.login method and explain why this bug occurs"

Kiro: "The bug occurs because email comparison is case-sensitive.
In register, email is stored as-is: Test@Example.com
In login, we search for: test@example.com
These don't match."

"Fix this bug by normalizing email to lowercase in both register and login"

Kiro: *Updates AuthService*
```typescript
async register(email: string, password: string) {
  const normalizedEmail = email.toLowerCase();
  // ... rest of code
}

async login(email: string, password: string) {
  const normalizedEmail = email.toLowerCase();
  // ... rest of code
}

"Add test case for case-insensitive email login"

Kiro: *Creates test*
```typescript
it('should login with case-insensitive email', async () => {
  await authService.register('Test@Example.com', 'password123');
  const result = await authService.login('test@example.com', 'password123');
  expect(result.user.email).toBe('test@example.com');
});

1. Identify Code Smell → 2. Plan Refactoring → 3. Refactor → 4. Test → 5. Commit

"#File src/api/controllers/UserController.ts
This controller is too large (500 lines). Suggest refactoring strategy."

Kiro: "Suggestions:
1. Extract validation logic to separate validators
2. Move business logic to UserService
3. Create separate controllers for related features
4. Use middleware for common operations"

"Create refactoring plan following your suggestions"

Kiro: *Creates plan*
```markdown
1. Create UserValidator class
2. Move business logic to UserService
3. Split into:
   - UserProfileController
   - UserSettingsController
   - UserActivityController
4. Create auth middleware

"Implement refactoring step by step, starting with step 1"

"Run all tests to ensure refactoring didn't break anything"

1. Read Spec → 2. Review Code → 3. Check Tests → 4. Verify Requirements → 5. Provide Feedback

# Open .kiro/specs/feature-name/
- Read requirements.md
- Read design.md
- Understand what should be implemented

# Trong Kiro
"#Git
Review these changes and check for:
- Code quality
- Following design patterns
- Error handling
- Security issues
- Performance concerns"

Kiro: *Analyzes diff and provides feedback*

"Check if tests cover all acceptance criteria in requirements.md"

Kiro: *Compares tests with requirements*
"Coverage analysis:
✅ US-1: Covered by test_create_user
✅ US-2: Covered by test_login
❌ US-3: Missing test for password reset
✅ US-4: Covered by test_update_profile"

"Verify all requirements in requirements.md are implemented"

Kiro: *Checks implementation against requirements*

# In PR comments
"Overall looks good! Few suggestions:

1. Add test for US-3 (password reset)
2. Consider adding rate limiting to login endpoint
3. Extract validation logic to separate file

Spec reference: .kiro/specs/user-auth/requirements.md"

1. Address Feedback → 2. Update Code → 3. Update Tests → 4. Update Spec (if needed) → 5. Request Re-review

"Implement reviewer's suggestions:
1. Add test for password reset
2. Add rate limiting to login
3. Extract validation logic"

"Add missing test for US-3"

# If requirements changed
Update requirements.md with new requirements

git push
# Comment in PR: "Addressed all feedback, ready for re-review"

Developer 1 (Driver): Viết code
Developer 2 (Navigator): Review và suggest
Kiro: Generate boilerplate và tests

Navigator: "Chúng ta cần validate email format"
Driver: "Kiro, add email validation to RegisterSchema"
Kiro: *Adds validation*
Navigator: "Good, now add test for invalid email"
Driver: "Kiro, add test for invalid email format"
Kiro: *Adds test*

Developer 1: Write test
Developer 2: Implement code to pass test
Kiro: Generate additional test cases

1. Team gathers around one screen
2. One person drives (uses Kiro)
3. Team discusses và decides
4. Kiro implements decisions

Team: "Chúng ta cần implement payment processing"
Driver: "Kiro, create spec for payment processing"
Kiro: *Creates spec*
Team: *Reviews và discusses*
Team: "Looks good, let's implement"
Driver: "Kiro, start implementing tasks"
Kiro: *Implements*
Team: *Reviews code together*

1. Tech Lead creates spec
2. Commits spec to Git
3. Team reviews async
4. Comments on spec file
5. Tech Lead updates spec
6. Approve và start implementation

1. Check Updates → 2. Review Changes → 3. Update → 4. Test → 5. Fix Issues

"Review breaking changes in these package updates:
- express: 4.18.0 → 5.0.0
- prisma: 5.0.0 → 5.5.0"

Kiro: *Summarizes breaking changes*

"Fix test failures caused by Express 5.0 breaking changes"

Kiro: *Updates code to work with new version*

1. Requirements Change → 2. Update Spec → 3. Update Code → 4. Update Tests

Product: "We need to add 2FA to login"

Developer:
1. Update requirements.md
   "Add US-6: Two-Factor Authentication"

2. Update design.md
   "Add 2FA service and endpoints"

3. Update tasks.md
   "Add tasks for 2FA implementation"

4. Implement with Kiro

5. Update tests

# Auto-update with hooks
.kiro/hooks/update-docs.json:
{
  "when": {
    "type": "fileEdited",
    "patterns": ["src/api/**/*.ts"]
  },
  "then": {
    "type": "askAgent",
    "prompt": "Update OpenAPI spec if API changed"
  }
}

# When requirements change
1. Update requirements.md
2. Regenerate design.md
3. Regenerate tasks.md
4. Update implementation

# Always review:
- Code changes
- Test coverage
- Spec alignment
- Documentation updates

1. Check steering files
   → Are they clear and specific?

2. Check spec
   → Are requirements detailed enough?

3. Provide examples
   "Generate code similar to this example: [paste example]"

4. Iterate
   "This is close but needs adjustment: [explain]"

1. Read error message
   "#Problems Explain this test failure"

2. Understand root cause
   Kiro: *Explains why test fails*

3. Fix
   "Fix the code to make this test pass"

4. Verify
   npm test

1. Ask Kiro for help
   "I'm stuck on implementing [feature]. Suggest approach."

2. Review spec
   Read requirements and design again

3. Break down problem
   "Break this complex task into smaller steps"

4. Search documentation
   Use MCP servers to search docs