Writing Effective Development Prompts

In this lesson we’ll cover how to write effective development prompts that reduce ambiguity, eliminate unnecessary exploration, and produce predictable, high-quality code from an LLM (here: Claude Code). Good prompts balance clarity with necessary context so the model makes useful assumptions rather than guessing your stack or file layout.

Why prompt quality matters

Vague prompts cause the assistant to infer project type, frameworks, file structure, and other assumptions.
Explicit prompts provide the context and constraints the assistant needs to produce focused, actionable results.
The result: less back-and-forth, fewer surprises, and a predictable file scaffold.

Bad prompt example

Prompt: “Make a login screen”

What happens with an ambiguous prompt When you issue a one-liner like “Make a login screen”, the assistant must guess critical details (is this Express, React, or another stack?) and often performs exploratory steps on your workspace. The example below shows the assistant probing the repository because it inferred an Express.js app from the folder name:

Enter to confirm · Esc to exit

* Welcome to Claude Code!
/help for help, /status for your current setup
cwd: /Users/jeremy/Repos/Claude Code Course/Express-login-demo

> Make a login screen

· Finagling... (esc to interrupt)

I will create a login screen for your Express application. Let me first explore the project structure to understand the current setup and then plan the implementation.

• List(~/Repos/Claude Code Course/Express-login-demo)
  └ Listed 2 paths (ctrl+r to expand)

• Read(~/Repos/Claude Code Course/Express-login-demo)
  └ Error: EISDIR: illegal operation on a directory, read

• Bash:
  find /Users/jeremy/Repos/Claude\ Code\ Course/Express-login-demo -type f \( -name "*.js" -o -name "*.json" -o -name "*.html" -o -name "*.css" \) | head -20

Do you want to proceed?
1. Yes
2. No, and tell Claude what to do differently (esc)

Because the folder contains “Express-login-demo”, Claude assumed Express and started scanning files. If the folder name were different, Claude might have assumed React, Vue, or another stack. Ambiguous prompts often trigger these kinds of exploratory behaviors. Better prompt example A concise, complete prompt lets Claude proceed without guessing. Below is a high-quality prompt that specifies the endpoint, inputs, validations, DB, hashing, token behavior, and error handling.

Create a POST /api/auth/login endpoint using Express.js with the following requirements:

- Input: email and password (both required)
- Validation: email must be a valid email; password must be at least 8 characters
- Use express-validator for input validation
- Look up users in PostgreSQL (pg) by email
- Compare passwords using bcrypt
- On success, return a JWT (24-hour expiration) that includes the user's id and email
- Response on success: `{"token": "...", "user": {"id": ..., "email": "...", "name": "..."}}`
- Implement comprehensive error handling:
  - Validation errors -> 400
  - Invalid credentials -> 401
  - Database connection errors -> 503
  - Generic server errors -> 500

Also create:
- A `.env` template for DB and JWT config
- A `schema.sql` to create the users table

Why this prompt works

Context: establishes Express.js, PostgreSQL, and the endpoint path.
Action: clearly states “Create POST /api/auth/login”.
Details: validation rules, hashing, token requirements, and error mappings.
Examples: explicit success response format and expected status codes.

Typical generated to-do list (condensed)

Initialize Node.js project (package.json)
Install dependencies: express, express-validator, bcrypt, jsonwebtoken, pg, dotenv, and nodemon (dev)
Create a basic Express app (server.js)
Create DB connection (config/database.js)
Implement POST /api/auth/login in routes/auth.js
Add .env and schema.sql
Add error handling and validation

Files created and their purpose

File	Purpose	Example
`server.js`	Entry point: express app and routes	`node server.js`
`routes/auth.js`	Authentication routes, including `POST /api/auth/login`	See example below
`config/database.js`	Exports a `pg` Pool instance configured from `process.env`	`module.exports = pool`
`.env`	Environment variables for DB and JWT	See example `.env`
`schema.sql`	SQL to create `users` table	See example `schema.sql`
`package.json`	Project metadata and scripts	`npm run dev`

Example .env template

PORT=3000
JWT_SECRET=your_jwt_secret_key_here
JWT_EXPIRES_IN=24h
# Database configuration
DB_HOST=localhost
DB_PORT=5432
DB_NAME=express_login_demo
DB_USER=your_db_user
DB_PASSWORD=your_db_password

Example package.json snippet

{
  "name": "express-login-demo",
  "version": "1.0.0",
  "description": "Express.js login demo with JWT authentication",
  "main": "server.js",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": ["express", "login", "jwt", "authentication"]
}

Common HTTP error mapping

Condition	Status Code	Example response
Validation errors	400	`{"errors": [...]}`
Invalid credentials	401	`{"message":"Invalid credentials"}`
Database connection error	503	`{"message":"Database connection error"}`
Generic server error	500	`{"message":"Internal server error"}`

Minimal example of routes/auth.js (concise pattern) This implementation demonstrates express-validator, bcrypt comparison, JWT generation, and consistent error handling.

// routes/auth.js
const express = require('express');
const { body, validationResult } = require('express-validator');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');
const pool = require('../config/database'); // pg Pool instance
const router = express.Router();

router.post(
  '/login',
  [
    body('email').isEmail().withMessage('Please provide a valid email'),
    body('password').isLength({ min: 8 }).withMessage('Password must be at least 8 characters')
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { email, password } = req.body;

    try {
      const client = await pool.connect();
      try {
        const result = await client.query('SELECT id, email, name, password_hash FROM users WHERE email = $1', [email]);
        if (result.rowCount === 0) {
          return res.status(401).json({ message: 'Invalid credentials' });
        }

        const user = result.rows[0];
        const match = await bcrypt.compare(password, user.password_hash);
        if (!match) {
          return res.status(401).json({ message: 'Invalid credentials' });
        }

        const token = jwt.sign({ id: user.id, email: user.email }, process.env.JWT_SECRET, {
          expiresIn: process.env.JWT_EXPIRES_IN || '24h'
        });

        return res.json({ token, user: { id: user.id, email: user.email, name: user.name } });
      } finally {
        client.release();
      }
    } catch (err) {
      console.error('Database error:', err);
      return res.status(503).json({ message: 'Database connection error' });
    }
  }
);

module.exports = router;

Note: Ensure config/database.js correctly exports a pg Pool instance configured via process.env values. Database schema example A simple schema.sql to create the users table used above:

-- schema.sql
CREATE TABLE IF NOT EXISTS users (
  id SERIAL PRIMARY KEY,
  email TEXT UNIQUE NOT NULL,
  name TEXT,
  password_hash TEXT NOT NULL,
  created_at TIMESTAMP DEFAULT now()
);

Why the explicit prompt produced good output

It specified the stack (Express.js), the exact route to implement, validation constraints, the database, hashing algorithm, token behavior, response formats, and expected status codes.
With those constraints, the assistant generated a predictable file structure, .env template, and an implementation plan.

Prompt engineering formula (practical) Use this pattern when you craft prompts: Context → Action → Details → Examples

Context: What exists already (project type, folder structure, relevant files)
Action: Exactly what you want (add endpoint, create files, run tests)
Details: Constraints, libraries, edge cases, and formats
Examples: Example request/response or code snippets to clarify expected outputs

Helpful rules for good prompts

Clear: Avoid ambiguity; name frameworks and endpoints.
Complete: Include required validations, status codes, and response shapes.
Contextual: Provide repository context or file layout if it matters.

Tip: Spending a minute writing a clear, complete prompt can save many minutes of revisions. Aim for the Goldilocks zone — neither too vague nor overly verbose.

Common pitfalls to avoid

Vagueness that leads the assistant to assume stack or file layout.
Conflicting constraints that leave the model unsure which rule to follow.
Omitting expected response formats (e.g., not specifying JSON structure).

References

Express: https://expressjs.com/
express-validator: https://express-validator.github.io/docs/
bcrypt: https://www.npmjs.com/package/bcrypt
jsonwebtoken: https://www.npmjs.com/package/jsonwebtoken
pg (node-postgres): https://node-postgres.com/
PostgreSQL docs: https://www.postgresql.org/docs/

Summary

Vague prompts cause LLMs to infer and explore; explicit prompts produce focused, actionable output.
Use the Context → Action → Details → Examples pattern and the three Cs (clear, complete, contextual) to get consistent, useful results.
When uncertain, include an example response or code pattern — examples guide the model to your intended shape of output.

This lesson demonstrates how precise prompts reduce guessing and produce predictable, high-quality code scaffolding and implementations. Apply these techniques when interacting with Claude Code or any LLM-assisted development tool.

Introduction

Getting Started with Claude Code

Working with Claude Code

Code Review with Claude Code

Security Auditing with Claude Code

Advanced Features

Writing Effective Development Prompts

Watch Video