AI-Assisted Development
Use AI coding tools (Cursor, Claude Code, Copilot) to accelerate how you build — with clear prompts and disciplined review.
AI touches your work in two distinct ways. The first is how you build: tools like Cursor, Claude Code, and Copilot that generate, refactor, and explain code as you work. (The second — features you build into the app — is a separate topic.) These assistants are most effective when you treat them as a fast, tireless pair programmer that still needs precise direction and careful review.
The quality of the output is bounded by the quality of the prompt and the surrounding context. Good prompts are specific and scoped: 'Write RTL tests for this ExpenseForm component', 'Convert this JS file to TypeScript with proper interfaces', 'Extract this repeated JSX into a reusable component', 'Explain what this useEffect does and identify any bugs'. Each gives the model a concrete, verifiable task tied to code it can see.
The non-negotiable discipline is review. AI-generated code can be subtly wrong — plausible APIs that don't exist, missing edge cases, or security issues — so you own every line you commit. Read it as if a junior engineer wrote it: run the tests, check the types, and verify behaviour before merging. The productivity win comes from the model doing the typing and boilerplate, not from skipping engineering judgement.
Treat an AI coding assistant like a very fast junior engineer on the team: it can scaffold a service, write boilerplate DTOs, or draft tests quickly, but you still code-review the PR, run the build, and own correctness. You wouldn't merge a junior's Spring controller without reading it — same rule applies to generated code.
- Specific, scoped prompts that reference visible code ('write RTL tests for this component') outperform vague ones.
- You own every committed line: review AI output for hallucinated APIs, missing edge cases, and security issues.
- The win is offloading typing and boilerplate, not offloading engineering judgement — tests and types still gate merges.
- Distinguish AI that accelerates how you build from AI features you ship to users; this topic is the former.
Worked Code
// Good prompts for AI coding assistants:
// "Write RTL tests for this ExpenseForm component"
// "Convert this JS file to TypeScript with proper interfaces"
// "Extract this repeated JSX into a reusable component"
// "Explain what this useEffect does and identify any bugs"Interview-Ready Q&A
The upside is speed: assistants like Claude Code, Cursor, or Copilot draft boilerplate, tests, and refactors far faster than typing by hand, and they can explain unfamiliar code. The risks are hallucinated APIs, plausible-but-wrong logic, missing edge cases, and accidentally introducing security issues or copied licensed code. I mitigate this by giving specific, scoped prompts; keeping changes small and reviewable; running the type checker and tests on the output; and reading every generated line as carefully as a teammate's PR. The model does the typing — I keep the judgement.
- 1Specific, scoped prompts beat vague ones — reference the actual code and a verifiable outcome.
- 2Always review generated code: run tests, check types, watch for hallucinated APIs and security bugs.
- 3AI accelerates building; it does not remove your ownership of correctness.