Prompts That Actually Work: Writing for AI Coding Tools

You write a prompt. The AI generates code. Sometimes it's perfect. Sometimes it's garbage. Mostly it's somewhere in between—functional but not quite right.

What makes the difference?

After analyzing thousands of successful and failed AI coding sessions, we've identified the patterns that separate prompts that work from prompts that waste your time.

The Anatomy of a Good Prompt

Every effective prompt has four components:

1. Context

What already exists? What doesn't the AI know that it needs to know?

Bad:

Add authentication to my app

Good:

I have a React app using TanStack Router.
I need email/password authentication.
I'm using PostgreSQL with Drizzle ORM.
I want to use Better Auth.

The AI can't read your mind. It can't see your codebase (unless you've configured context). Tell it what it needs to know.

2. Specification

What exactly should the output do? Be specific.

Bad:

Make a user dashboard

Good:

Create a dashboard component that shows:
- User's name and email at the top
- A grid of their recent projects (last 5)
- Each project card shows: name, status, last modified date
- Clicking a project navigates to /project/[id]

Vague specs produce vague outputs. If you can't describe it precisely, you're not ready to build it.

3. Constraints

What should the AI NOT do? What patterns should it follow?

Bad:

Make it look nice

Good:

Use our existing shadcn/ui components.
Follow the styling patterns in our other dashboard pages.
Don't add new dependencies.
Keep the component under 150 lines.

Constraints prevent over-engineering and keep code consistent with your existing patterns.

4. Format

What should the output look like?

Bad:

Give me the code

Good:

Create a single React component.
Export it as the default export.
Include TypeScript types for all props.
Add a brief comment explaining the main logic.

Explicit format requirements produce consistent, usable output.

Prompt Patterns That Work

The Step-by-Step Pattern

For complex features, break them into sequential prompts:

Step 1: Create the database schema for user preferences
Step 2: Create the API endpoint to update preferences
Step 3: Create the React form component to edit preferences
Step 4: Connect the form to the API

Each step is simple enough for the AI to handle reliably. You can verify each step before moving on.

The Example Pattern

Show, don't just tell:

Create a new API endpoint for updating user profiles.
Follow the same pattern as our existing endpoints.

Example (existing endpoint):
[paste existing code]

New endpoint should:
- Accept PATCH requests to /api/users/[id]/profile
- Validate input with zod
- Return the updated user object

Examples are worth a thousand words of specification.

The Fix-and-Explain Pattern

When debugging:

This code isn't working as expected:
[paste code]

Expected behavior: Users should see a loading state while data fetches
Actual behavior: The component renders empty, then shows data abruptly

Please:
1. Identify the issue
2. Explain why it's happening
3. Provide the fix

Asking for explanation ensures the AI understands the problem, not just pattern-matches to a solution.

The Refactor Pattern

When improving existing code:

Refactor this component:
[paste code]

Goals:
- Extract reusable logic into custom hooks
- Improve error handling
- Add loading and error states
- Keep the same external API (props and behavior)

Please explain each change you make.

Clear refactoring goals prevent the AI from "improving" things you didn't want changed.

What To Include In Context

The best prompts reference existing code. Here's what to include:

Always include:

• Relevant type definitions
• Related components/functions the new code will interact with
• Example patterns from your codebase

Include when relevant:

• Database schema
• API response shapes
• Environment/config considerations

Don't include:

• Unrelated code (wastes context window)
• Generated code that might have errors
• External library documentation (AI likely knows it)

The LucidCode Advantage

Every task in your LucidCode implementation kanban comes with a ready-to-paste prompt. These prompts are:

• Pre-formatted with your project's context
• Specific to exactly what needs to be built
• Constrained to your existing patterns
• Sequenced so each builds on the last

Instead of crafting prompts from scratch, you copy, paste, and build.

Common Prompt Mistakes

Mistake 1: Assuming Knowledge

Update the auth to use the new token format

What new format? The AI doesn't know about your team's Slack discussions.

Mistake 2: Combining Unrelated Tasks

Add user authentication and also make the homepage responsive

One task per prompt. Always.

Mistake 3: Asking for Opinions

What's the best way to handle state in this app?

AI will give you an answer, but it's guessing. Decide your patterns, then ask for implementation.

Mistake 4: No Success Criteria

Make the form better

Better how? Faster? Prettier? More accessible? With validation? Define success.

The Prompt Checklist

Before sending any prompt:

• [ ] Does it include necessary context?
• [ ] Is the specification precise?
• [ ] Are constraints explicit?
• [ ] Is the expected output format clear?
• [ ] Is this a single, focused task?
• [ ] Could someone else understand what you want from this prompt alone?

If you can't check all boxes, refine the prompt before sending.