How to Write Code with AI
AI coding tools have changed how software gets built. Instead of writing every line manually, you describe what you need and the AI generates the implementation. But the tools work much better when you follow a structured approach. Developers who get the best results from AI assistants are not necessarily the most skilled programmers, they are the ones who have learned how to communicate clearly with the AI and review its output critically.
Step 1: Choose Your AI Coding Tool
The right tool depends on three factors: your experience level, whether you want to work in an IDE or a browser, and how much you want to spend.
If you are an experienced developer who works in VS Code or a similar editor, start with Cursor or GitHub Copilot. Both integrate directly into your editor and provide real-time code suggestions as you type. Cursor's Composer feature is particularly strong for multi-file editing, while Copilot integrates deeply with GitHub workflows. Windsurf's free tier offers unlimited autocomplete at no cost if you want to try AI coding without any financial commitment.
If you are new to coding and want the simplest possible setup, use Replit. It runs entirely in the browser, so there is nothing to install. The editor, terminal, package manager, and deployment pipeline are all built in. You write code, hit run, and see results immediately.
If you want an AI to build a complete application from a description, use Replit Agent (for full applications with databases and auth), Lovable (for SaaS MVPs), or Bolt.new (for quick prototypes). These tools generate entire projects rather than helping you write individual functions.
For complex development tasks like large refactors, bug hunts, and codebase migrations, Claude Code operates in the terminal and autonomously plans, writes, tests, and fixes code across your entire project.
Step 2: Set Up Your Environment
For IDE-based tools (Cursor, Copilot, Windsurf): Install the editor or extension, sign in with your account, and open a project. The tool indexes your project files and begins providing suggestions immediately. If you are using Cursor, create a .cursorrules file in your project root with instructions about your preferred coding style, framework conventions, and patterns you want the AI to follow. This file significantly improves the relevance of generated code.
For browser-based tools (Replit, Lovable, Bolt.new): Create an account on the platform, start a new project, and choose your language or framework. No local setup is required. These tools provide the entire development environment in the browser.
For terminal tools (Claude Code): Install the CLI, authenticate with your account, and navigate to your project directory. The agent will scan your project structure and codebase when you give it a task.
Regardless of which tool you use, start with a small project or a contained task rather than asking the AI to build something complex from scratch. Your first AI coding sessions should teach you how the tool responds to your instructions, what level of detail it needs, and where it tends to make mistakes. This calibration saves time on every subsequent task.
Step 3: Write Clear, Specific Prompts
The quality of AI-generated code is directly proportional to the quality of your prompt. Vague instructions produce generic, often wrong code. Specific instructions produce targeted, useful implementations.
Bad prompt: "Make a login page."
Good prompt: "Create a login page component in React with TypeScript. It should have email and password fields with validation, a submit button that calls the /api/auth/login endpoint with a POST request, error handling that shows a message below the form when the API returns a 401, and a 'forgot password' link below the submit button that navigates to /forgot-password. Use Tailwind CSS for styling. The component should match the existing form pattern in src/components/SignupForm.tsx."
The good prompt tells the AI the technology stack (React, TypeScript, Tailwind), the specific fields and behaviors, the API endpoint to call, how to handle errors, and an existing file to use as a reference for coding patterns. Every additional detail reduces the chance that the AI produces something you need to rewrite.
Include these details in your prompts when relevant: programming language and version, framework and library versions, file location for the generated code, function signatures and return types, error handling expectations, existing patterns to follow, and test requirements.
Step 4: Work Iteratively, Not All at Once
The biggest mistake people make with AI coding tools is asking for too much in a single request. "Build me a complete project management tool with user accounts, teams, task boards, file uploads, and notifications" will produce shallow, buggy code that needs extensive reworking. Breaking this into smaller pieces produces dramatically better results.
A productive workflow looks like this:
First, ask the AI to set up the project structure, data models, and basic configuration. Review this foundation before moving on. Second, build one feature at a time, starting with the core functionality. Get the data model and basic CRUD operations working before adding UI polish. Third, test each piece before building the next. Bugs compound, and catching them early prevents the AI from building on a broken foundation.
For experienced developers using IDE tools, the iteration happens at a smaller scale. You write a function signature and let the AI complete the implementation. You review the implementation, adjust any issues, then move to the next function. This tight loop of intent, generation, review, and adjustment is where AI coding tools produce the most value.
For non-developers using app builders, iteration means describing one screen or feature, reviewing what the AI builds, providing feedback ("make the sidebar narrower," "add a search filter to the table"), and refining before moving to the next feature. Think of the AI as a fast but literal-minded developer who needs clear feedback on each piece.
Step 5: Review and Test Everything
AI-generated code can contain bugs, security vulnerabilities, performance issues, and references to functions or APIs that do not exist. Treating AI output as a first draft that requires human review is essential, not optional.
Read the code. Even if you are not an experienced programmer, reading through the generated code builds understanding and catches obvious issues. Look for hardcoded values that should be variables, missing error handling, and patterns that differ from the rest of your codebase.
Run the code. Execute the generated code and test it with normal inputs, edge cases, and intentionally invalid inputs. AI-generated code often works for the happy path but fails on error conditions, empty inputs, null values, and boundary cases.
Check security. Look for SQL injection vulnerabilities (user input directly in database queries), cross-site scripting risks (unescaped user content rendered in HTML), missing authentication or authorization checks, hardcoded API keys or credentials, and insecure default configurations. AI models generate code that works functionally but may not consider the security implications of each decision.
Verify external references. When the AI generates code that calls an API, uses a library function, or references documentation, verify that the API endpoint, function, or method actually exists. AI models sometimes hallucinate plausible-sounding function names that do not exist in the library.
Step 6: Refine Through Conversation
When the generated code is not right, do not start over. Tell the AI specifically what needs to change. AI coding tools maintain conversation context, so each follow-up message builds on the previous interaction.
Be specific about what is wrong. "This does not work" gives the AI nothing to work with. "The handleSubmit function is not awaiting the API response, so the loading state clears before the response arrives" gives it a precise problem to fix.
Paste error messages. If the code produces an error, paste the full error message and stack trace into the conversation. The AI can usually diagnose the problem directly from the error output and produce a targeted fix.
Reference specific lines or functions. "In the UserList component, change the sort to be descending by creation date instead of ascending" is more effective than "fix the sorting." The more precisely you identify the location and nature of the change, the more precisely the AI can make it.
Ask for explanations. When the AI generates code you do not understand, ask it to explain what each part does and why it made specific choices. This is valuable for learning and for catching cases where the AI made assumptions that do not match your requirements.
Common Mistakes to Avoid
Accepting code without reading it. The biggest risk with AI coding tools is treating them as infallible. Every experienced AI-assisted developer has a story about merging AI-generated code that looked correct but contained a subtle bug. Reading the code is not optional, even when it looks clean.
Over-prompting on the first try. A 500-word prompt asking for a complex feature produces worse results than breaking the same work into five focused 100-word prompts. The AI's accuracy improves when it can focus on one well-defined task rather than juggling many requirements simultaneously.
Not learning the fundamentals. Using AI to avoid learning programming concepts creates a dependency that becomes a problem when the AI produces incorrect code and you cannot tell what is wrong. If you are learning to code, use the AI as a tutor that explains concepts, not as a replacement for understanding them. Structured coding courses paired with AI tools produce better long-term results than AI tools alone.
Ignoring your project's existing patterns. AI-generated code that uses a different style, framework, or pattern than the rest of your project creates maintenance problems. Always point the AI to existing files as reference examples, and use project configuration files (.cursorrules, .copilot, etc.) to encode your conventions.
Tips for Getting Better Results
Use comments as prompts. In IDE-based tools, writing a comment that describes what the next function should do often produces better completions than using the chat interface. The comment becomes documentation that stays in your code, and the AI treats it as a detailed specification for the code it generates below.
Show examples. When you want code in a specific style, paste an example of existing code that follows that style and tell the AI "follow this pattern." This is more effective than describing the pattern in words because the AI can match specific formatting, naming conventions, and structural choices directly.
Use test-driven development. Write your tests first, then ask the AI to write the implementation that passes those tests. This gives the AI a concrete, verifiable specification and makes it immediately clear whether the generated code works correctly.
Ask for alternatives. If the first implementation does not feel right, ask the AI for a different approach. "Show me another way to implement this, optimizing for readability instead of performance" or "rewrite this using the repository pattern instead of inline database queries" can produce meaningfully better solutions.
AI coding tools produce the best results when you break work into small, specific tasks, write detailed prompts, review every line of output, and iterate through conversation. The developers who get the most value from these tools are not the ones who trust the AI blindly, but the ones who know how to direct it precisely and catch its mistakes.