AI-Assisted Development

AI tools have become part of the daily workflow for most software engineers. This is not about replacing developers — it is about changing what developers spend their time on. The shift is from writing every line of code yourself to directing, reviewing, and verifying AI-generated output.

Understanding how to use these tools effectively is now a core engineering skill, not a novelty.

The Tool Landscape

AI-assisted development tools fall into several categories, each with different strengths and interaction models.

Inline Completion: GitHub Copilot

GitHub Copilot integrates directly into your editor (VS Code, JetBrains, Neovim). It predicts what you are about to type and offers completions as you code.

• Tab completion — suggests the next line or block based on context
• Copilot Chat — ask questions about your code in a sidebar panel
• Best for: repetitive patterns, boilerplate, filling in implementations when the structure is clear
• Limitation: suggestions are based on surrounding context, so quality depends on how well your existing code signals intent

AI-Native Editor: Cursor

Cursor is a fork of VS Code built around AI interaction as the primary workflow.

• Cmd-K — select code and give natural language instructions to transform it
• Composer — multi-file editing through conversation, can create and modify several files at once
• Codebase-aware — indexes your project for better context in suggestions
• Best for: refactoring across files, generating new features from descriptions, rapid prototyping

CLI Agent: Claude Code

Claude Code runs in your terminal and operates as an autonomous coding agent.

• Multi-file edits — reads, understands, and modifies multiple files in a single session
• Git integration — can create commits, branches, and PRs
• Shell access — can run tests, linters, and build commands to verify its own work
• Best for: complex multi-file changes, codebase exploration, tasks that require running and testing code

Conversation-Based: ChatGPT & Claude Web

Web-based AI interfaces where you paste code and describe what you need.

• Copy-paste workflow — you provide context manually
• Good for: explaining concepts, debugging with error messages, exploring design alternatives
• Limitation: no direct access to your codebase, so you must provide all relevant context yourself
• Best for: learning, design discussions, one-off questions that do not require deep project context

How AI Changes the Engineering Role

The day-to-day work of a software engineer shifts when AI tools are in the picture:

The role becomes more about judgment — deciding what to build, evaluating whether AI output is correct, and knowing when to reject AI suggestions.

This does not mean the role is easier. It means the difficulty shifts. Writing a for loop is easy; evaluating whether AI-generated code handles concurrent access correctly is hard. The mechanical parts get automated; the judgment parts become the primary skill.

The Verification Mindset

The most important mental model for AI-assisted development is the verification mindset: treat every piece of AI output as unverified until you have personally confirmed it is correct. This applies to:

• Code — read it line by line, run the tests, check the edge cases
• Explanations — AI can sound authoritative while being wrong; cross-reference with documentation
• Suggestions — AI optimizes for plausibility, not correctness; plausible-looking code can have subtle bugs
• Dependencies — AI may suggest packages that are deprecated, unmaintained, or do not exist

The engineers who get the most value from AI are not the ones who accept output fastest. They are the ones who verify output most thoroughly.

What AI Is Good At

AI tools excel at tasks that are well-defined, repetitive, or pattern-based:

• Boilerplate code — API routes, database models, config files, CRUD operations. AI can generate a full CRUD handler with validation, error handling, and proper HTTP status codes in seconds.
• Regex and string manipulation — writing and explaining regular expressions. Ask AI to explain a complex regex and it will break down every character group with clarity that most documentation cannot match.
• Test generation — creating unit tests from function signatures and docstrings. Provide a function and ask for tests covering happy paths, edge cases, and error cases. AI produces good test scaffolding that you refine.
• Translations — converting code between languages (Python to TypeScript) or translating UI strings. AI handles both syntactic conversion and idiomatic adaptation.
• Refactoring — renaming, extracting functions, converting patterns (callbacks to async/await). Mechanical transformations with clear rules are AI's sweet spot.
• Documentation — generating JSDoc, README sections, API docs from code. AI reads structure and produces documentation that captures the "what" accurately, even if the "why" needs human editing.
• Exploring unfamiliar codebases — explaining what files do, tracing data flow, identifying patterns. When you join a new team, AI can compress days of code reading into hours of guided exploration.

What AI Is Bad At

AI struggles with tasks that require judgment, context, or deep understanding:

• Novel architecture decisions — AI can suggest patterns it has seen before, but it does not understand your system's constraints, team capabilities, or business roadmap. It will recommend microservices for a two-person team because that is what the training data emphasizes.
• Understanding business context — AI does not know your users, your SLAs, or why that edge case matters to your biggest customer. It cannot weigh the cost of a bug against the cost of delaying a feature.
• Security-critical code — AI confidently generates plausible-but-insecure code. It will implement JWT authentication that looks correct but uses a symmetric algorithm where asymmetric is required, or skip token expiration checks entirely. Authentication, authorization, and cryptography require human expertise.
• Subtle performance optimization — AI does not profile your system. It suggests generic optimizations (memoization, caching, batch processing) that may not match your actual bottlenecks. Real optimization requires measurement, not guessing.
• Hallucinated APIs — AI invents function signatures, library methods, and configuration options that do not exist, with complete confidence. It will call prisma.user.softDelete() (which does not exist) or suggest deprecated Node.js APIs as if they are current.

Why This Matters for NZ Jobs

The New Zealand tech market has shifted. AI-assisted development is no longer a differentiator — it is an expectation.

• Interview questions — many NZ companies now ask about AI tool usage in interviews. Common questions include: "How do you use AI in your workflow?", "How do you verify AI-generated code?", and "Give an example of when AI gave you incorrect output and how you caught it." Being able to discuss your AI workflow thoughtfully signals maturity.
• Job descriptions — roles increasingly list "experience with AI coding tools" or "familiarity with GitHub Copilot" as preferred qualifications. Some companies frame it differently: "comfort with modern development tooling" or "experience with productivity tools." The expectation is the same.
• Team expectations — engineers who use AI tools effectively ship faster, and teams notice the difference. If your colleague generates a comprehensive test suite in 10 minutes while you spend two hours writing the same tests manually, that gap is visible in sprint velocity.
• The real skill — companies do not want someone who blindly copies AI output. They want someone who uses AI to move faster while maintaining quality. The skill is not "using AI" but "using AI effectively while maintaining code quality." This means knowing when to use AI, when not to, and how to verify everything it produces.
• Competitive advantage — the NZ market is small enough that individual productivity differences matter. An engineer who effectively uses AI tools can realistically handle work that would otherwise require 1.5 to 2 engineers for routine tasks, freeing up time for the complex, high-judgment work that actually differentiates products.

How This Section Is Organized

Daily Workflows

Practical patterns for using AI in everyday engineering: code generation, code understanding, debugging, code review, refactoring, documentation, and DevOps. Includes concrete prompt examples and quality assessments.

Best Practices

How to use AI tools effectively without losing your engineering edge: prompt engineering, reviewing AI output, security considerations, staying sharp, team practices, and knowing when not to use AI.

A Typical AI-Assisted Workflow

To make this concrete, here is what an AI-assisted development session might look like for a typical feature:

1. Understand the requirement — read the ticket, clarify with the PM if needed. This is human work.
2. Explore the codebase — use Claude Code or Cursor to understand the existing patterns: "Show me how other API endpoints handle pagination in this project."
3. Generate the scaffold — ask AI to generate the route handler, validation schema, and database query following the project's existing patterns.
4. Review and refine — read every line. Fix the authorization check AI forgot. Add the edge case for empty results. Remove the unnecessary dependency AI imported.
5. Generate tests — ask AI to write unit tests for the function, covering happy paths and edge cases. Add the domain-specific test case AI did not know about.
6. Run the tests — verify everything passes. Fix the one test where AI mocked the wrong return type.
7. Generate documentation — ask AI to add JSDoc comments and update the API docs.
8. Self-review — ask AI to review your diff for bugs and security issues before submitting the PR.

The human directs, reviews, and decides at every step. The AI handles the mechanical parts. This is the workflow that makes AI-assisted development effective.

Notice what the human does at each step: verify, correct, supplement, and decide. The AI never has the final say. The total time for this feature might be 2 hours instead of 6, but the quality is the same — because the human applied judgment at every decision point.

The Evolution of AI Tools

AI coding tools are improving rapidly. What was state-of-the-art a year ago is now table stakes. Some trends worth watching:

• Longer context windows — tools can now process entire codebases, not just single files, leading to more context-aware suggestions
• Agentic workflows — tools like Claude Code can execute multi-step plans autonomously: read code, make changes, run tests, fix failures, and iterate
• Specialized models — models trained or fine-tuned specifically for code perform better than general-purpose models on engineering tasks
• IDE integration depth — AI is moving from a sidebar chat to being embedded in every part of the development workflow: commit messages, PR descriptions, code review, debugging

The core principles on this page — verify everything, understand what you ship, maintain your fundamentals — remain constant regardless of how the tools evolve. Tools change; engineering discipline does not.

The Bottom Line

AI tools make you faster at producing code. They do not make you better at engineering. The difference between a junior developer pasting AI output and a senior developer directing AI is judgment — knowing what to ask for, evaluating whether the output is correct, and understanding the implications of the code you ship.

Use these tools. But understand every line you commit.