Code Generation

• Boilerplate — DTOs, controllers, CRUD scaffolding, config files.
• Unit tests for existing functions — coverage that would otherwise rot.
• Migrations & schema changes — repeating patterns across files.
• Translations — Python → TypeScript, jQuery → React, Java → Kotlin.
• Glue code — wiring two libraries together, format converters, parsers.
• One-off scripts — data cleanup, file renaming, log analysis.

• Feature implementation — when the spec is clear and the codebase is conventional.
• Refactoring — extracting components, renaming, splitting modules.
• Bug fixes from a stack trace — paste error + relevant code, get a fix.
• UI from a screenshot or Figma export.

• Architecture decisions — agents will happily invent a microservice you didn't need.
• Cross-cutting concerns not visible in the local context (auth, multi-tenant rules).
• Performance-critical hot paths — generated code is correct but rarely optimal.
• Niche libraries / new APIs — model may hallucinate functions that don't exist.

Better than diving in. Write a short spec — the model will follow it.

// Bad
"add caching"

// Good
"Add an LRU cache to ProductService.getById:
- Max 1000 entries
- 5-minute TTL
- Cache key: `product:${id}`
- Use the existing Caffeine library; see CacheConfig.java
- Add a unit test that verifies eviction after 1001 inserts"

Point the agent at an example. "Build a UserController like ProductController in src/api/products/" gives it the conventions, naming, and test style without you spelling it out.

For agents: small task → run tests → review diff → fix or accept. Don't ask for "the whole feature" in one go — break it into steps you can verify in minutes.

1. You: write the test cases describing desired behavior.
2. Agent: implement until tests pass.
3. You: review diff, accept.

Tests act as a contract — they pin down intent better than prose, and the agent gets a fast feedback signal.