A practical guide to coding with AI assistance

You have an AI coding assistant. Now what?

The difference between developers who find AI genuinely useful and those who dismiss it as “overhyped autocomplete” often comes down to technique. The tools are capable, but getting good results requires understanding how to work with them effectively.

This guide covers practical techniques for using AI coding assistants productively, based on patterns observed across thousands of developers. No theory, no hype—just methods that work.

The fundamental shift in workflow

Working with AI assistance requires a mental model adjustment. Traditional coding is additive: you type characters that become code. AI-assisted coding is more like editing: you generate drafts and refine them.

This shift has implications:

You spend more time reviewing and less time typing. The bottleneck moves from your fingers to your judgement. Being a fast typist matters less; being a good code reviewer matters more.

Expressing intent becomes a core skill. The quality of AI output correlates directly with how clearly you communicate what you want. Vague requests produce vague results.

Iteration is the norm. Getting perfect output on the first try is rare. Expect to refine through multiple rounds of generation and editing.

Prompting techniques that work

Be specific about requirements

The single most important prompting skill is specificity. Compare these prompts:

Vague: “Write a function to validate emails”

Specific: “Write a TypeScript function that validates email addresses. It should check for: a valid format with @ and domain, no consecutive dots, maximum length of 254 characters. Return a boolean. Include JSDoc comments.”

The specific prompt constrains the output space, giving the model clear criteria to meet. The vague prompt leaves too much to interpretation.

Include context the model cannot see

AI assistants typically see your current file and perhaps some surrounding context. They do not see your team’s conventions, your architecture decisions, or your past discussions. Make implicit knowledge explicit:

// Our convention is to throw AppError for user-facing errors and use error codes
// from src/constants/errors.ts. See existing handlers in src/api/handlers/ for patterns.
// Write a handler for POST /api/orders that validates the request body,
// creates an order in the database, and returns the created order with status 201.

This context saves multiple rounds of correction.

Use examples to show patterns

When you want output to follow a specific pattern, showing an example is more effective than describing it:

// Generate API route handlers following this pattern:
// 
// export async function GET(req: Request) {
//   try {
//     const data = await fetchData();
//     return Response.json({ success: true, data });
//   } catch (error) {
//     return Response.json({ success: false, error: error.message }, { status: 500 });
//   }
// }
//
// Now create a handler for fetching user preferences by user ID.

The model infers structure, naming conventions, and error handling patterns from the example.

Break complex tasks into steps

Large tasks produce worse results than small, focused tasks. Instead of:

“Refactor this 500-line class to use dependency injection and add tests”

Try:

1. “Identify which dependencies in this class should be injected”
2. “Create interfaces for these dependencies”
3. “Refactor the constructor to accept these interfaces”
4. “Write a unit test for the calculateTotal method using mocked dependencies”

Each step is verifiable before proceeding to the next.

State what you do not want

Negative constraints are often as useful as positive requirements:

“Create a React form component for user registration. Do not use any external form libraries—use native React state. Do not add inline styles. Do not include form validation logic; that will be handled separately.”

This prevents the model from making assumptions that create extra work.

Workflow integration patterns

The comment-first pattern

Write comments describing what you want, then let the AI implement:

// Parse command-line arguments
// Expected format: script.js --input file.txt --output result.json --verbose
// Return an object with input, output (default: stdout), and verbose (default: false)
function parseArgs(args) {

The comment serves as documentation and as a prompt. If the generated code does not match the comment, one of them needs to change.

The test-first pattern

Write tests that describe expected behaviour, then generate implementation:

describe('PriceCalculator', () => {
  it('applies percentage discounts correctly', () => {
    const calc = new PriceCalculator();
    expect(calc.applyDiscount(100, { type: 'percentage', value: 20 })).toBe(80);
  });

  it('applies fixed discounts correctly', () => {
    const calc = new PriceCalculator();
    expect(calc.applyDiscount(100, { type: 'fixed', value: 15 })).toBe(85);
  });

  it('does not allow negative prices', () => {
    const calc = new PriceCalculator();
    expect(calc.applyDiscount(10, { type: 'fixed', value: 20 })).toBe(0);
  });
});

// Now implement PriceCalculator to pass these tests

The tests constrain the implementation and provide immediate verification.

The scaffold-then-fill pattern

Generate structure first, then fill in details:

1. Ask for a class skeleton with method signatures and docstrings
2. Review and adjust the structure
3. Implement each method individually

This catches architectural issues before investing time in implementation details.

The explain-then-modify pattern

When working with unfamiliar code:

1. Ask the AI to explain what the code does
2. Verify the explanation matches your understanding
3. Ask for modifications with reference to the explained behaviour

This ensures you and the AI share the same understanding before making changes.

When to trust AI suggestions

Not all suggestions deserve equal trust. Here is a rough hierarchy:

High confidence situations

• Common patterns in widely-used languages (React components, Express routes, Python data processing)
• Boilerplate code with well-defined structure
• Standard library usage
• Syntax you could verify by glancing at documentation

In these cases, quick review before accepting is usually sufficient.

Medium confidence situations

• Business logic implementing specific requirements
• Integration code between systems
• Error handling for non-obvious edge cases
• Performance-sensitive code

These require careful review. Read the code line-by-line. Consider edge cases. Think about failure modes.

Low confidence situations

• Security-critical code (authentication, encryption, input sanitisation)
• Code involving concurrency or race conditions
• Complex algorithms with correctness requirements
• Domain-specific logic requiring expert knowledge

Treat these as starting points, not solutions. Verify independently. Consider having a human expert review.

Zero confidence situations

• Anything involving secrets, credentials, or personal data
• Code that could cause data loss if wrong
• Legal or compliance-related logic
• Financial calculations with regulatory requirements

Do not rely on AI for these. Write them yourself with full attention and review. If you work with sensitive code regularly, choose a tool with strong security practices and clear data handling policies.

Common pitfalls and how to avoid them

The “good enough” trap

AI generates plausible code quickly. The temptation is to accept it because it looks reasonable and move on. This compounds into technical debt.

Solution: Establish review standards before you start. Decide what “done” means for each piece of code, and hold AI output to that standard.

The context amnesia problem

AI assistants forget previous conversations when starting new sessions. Explaining the same context repeatedly wastes time.

Solution: Maintain a project context file (many tools call this LURUS.md, CLAUDE.md, or similar) that contains project conventions, architecture decisions, and common patterns. Reference it in prompts or let the tool load it automatically. Lurus Code and similar agents automatically read these files at the start of each session.

The over-generation problem

It is easy to generate more code than you need. AI happily creates helper functions, extra error handling, and edge case coverage that you did not ask for.

Solution: Be explicit about scope. “Implement only this function, nothing else.” Review generated code for unnecessary additions before accepting.

The abstraction mismatch problem

AI tends toward common abstractions that may not fit your project. It might suggest class inheritance when your codebase uses composition, or add a state management library when you use React context.

Solution: Include explicit constraints about architectural style. “Use functional components with hooks, not class components.” “No external dependencies beyond what is already in package.json.”

The testing blindspot

AI can generate code that appears to work but fails on edge cases. Without tests, these issues surface later when they are harder to fix.

Solution: Generate tests alongside implementation, or write tests first. Use the test results as feedback for improving the generated code.

Productivity patterns from effective users

Morning planning sessions

Start each day with a brief session to outline what you will work on. Ask the AI to help break large tasks into smaller steps. This creates a roadmap that makes individual coding sessions more focused.

Rubber duck debugging with AI

When stuck on a problem, explain it to the AI as you would to a colleague. The process of articulating the problem often reveals the solution, and the AI may offer useful perspectives.

Documentation sprints

Use AI to generate initial documentation drafts, then refine them. This is less tedious than writing from scratch and often produces better coverage than you would write manually.

Refactoring assistance

Before large refactoring efforts, ask the AI to analyse the code and identify potential issues. Use this analysis to prioritise what to address and anticipate complications.

Learning new technologies

When working with unfamiliar frameworks or libraries, use the AI as an interactive reference. Ask it to explain concepts, generate example code, and clarify documentation.

Measuring your effectiveness

How do you know if AI assistance is helping? Track these indicators:

Time to completion. Are tasks taking less time? Measure for similar task types to account for variation.

Revision rate. How often do you need to significantly revise AI-generated code? Decreasing revision rates suggest improving prompting skills.

Bug introduction. Are AI-generated sections causing more bugs in code review or production? This indicates over-trust or insufficient review.

Learning curve. Are you getting better results over time with similar effort? Skills compound if you are learning from what works.

Integration with team workflows

Code review considerations

AI-generated code should meet the same review standards as human-written code. Do not rubber-stamp code because “the AI wrote it.” Conversely, do not reject code because an AI wrote it if it meets your quality bar.

Consider requiring authors to note which sections were AI-assisted. This helps reviewers calibrate attention appropriately.

Knowledge sharing

When AI helps you solve a problem in a novel way, share that knowledge. The prompt that worked for you will likely work for teammates.

Consistency across the team

Teams benefit from shared conventions about AI usage:

• Common project context files
• Agreed prompting patterns for common tasks
• Standards for what requires human implementation versus AI assistance
• Review practices for AI-generated code

The long view

AI coding assistants are tools. Like any tool, they amplify what you bring to them. Strong fundamentals in software design, clear thinking about requirements, and careful attention to quality produce better results with AI assistance than they would without.

The developers getting the most value from these tools are not those who generate the most code. They are those who use AI assistance strategically—for tasks where it excels—while maintaining the judgement and expertise that define good software engineering.

Start small. Pick one technique from this guide and apply it consistently. As it becomes natural, add another. Over time, you will develop an intuition for when and how to use AI assistance effectively.

The goal is not to maximise AI usage. The goal is to build better software, faster, with fewer errors. AI is one tool toward that goal, not the goal itself.

For teams seeking a balance of powerful AI assistance and data privacy, tools like Lurus Code offer full agent capabilities with the confidence that your code stays in EU data centers. Whatever tool you choose, these techniques will help you get more value from it.

Frequently Asked Questions

How long does it take to get good at using AI coding assistants?

Most developers report noticeable improvement within two to four weeks of consistent use. The learning curve is not steep, but developing intuition for what works takes practice. Focus on one technique at a time rather than trying everything at once.

Should I use AI for every coding task?

No. Some tasks are faster to do manually—quick edits, simple changes, code you can write without thinking. AI adds value for tasks that involve boilerplate, unfamiliar patterns, or where you benefit from a draft to react to. Develop judgement about when the overhead of prompting exceeds the benefit.

How do I handle AI suggestions that are almost right but need changes?

Edit them directly rather than regenerating. Regeneration produces different output that may have different problems. If the suggestion is 80% correct, fixing the 20% is usually faster than trying for a perfect generation.

What if my team has concerns about code quality with AI assistance?

Address concerns with process, not prohibition. Establish review standards, require testing, and track quality metrics. If quality issues emerge, adjust practices. Most teams find that AI-generated code, properly reviewed, meets their quality bar.

How do I avoid becoming dependent on AI assistance?

Maintain your fundamentals. Periodically code without assistance to ensure your skills remain sharp. Use AI as augmentation, not replacement. If you notice yourself unable to code without AI for tasks you previously handled easily, that is a signal to practice unassisted work.

What is the most common mistake new users make?

Accepting suggestions too quickly without review. The ease of Tab-to-accept creates a bias toward accepting plausible-looking code. Train yourself to actually read suggestions before accepting, especially for logic that is not immediately obvious.