Most prompt engineering advice is about making the model smarter. In practice, for the work I actually do, almost all of the gain came from one unglamorous change: describing the artifact I want instead of describing the topic.

This is a write-up of twenty prompts I built for the parts of software work that keep getting rewritten from scratch — API contracts, database schemas, review checklists, READMEs, postmortems, PR descriptions, commit messages, test strategies, CI config — and the four lessons that survived contact with real projects.

Lesson 1: name the artifact

Compare these two instructions:

Design an API for a resource.

Design a complete REST API for [RESOURCE] CRUD operations, with proper HTTP methods, status codes, request/response schemas, and pagination. Include auth, validation, and rate-limiting notes.

The second one is longer by about thirty words and worth far more than that. It names the artifact (a REST API), the scope (CRUD), the sections that must be present (methods, status codes, schemas, pagination), and the cross-cutting concerns (auth, validation, rate limiting). The model now has a checklist to fill rather than an essay to write.

The same pattern holds across the set:

Postgres schema for [DOMAIN], 5 entities. 
20-item code review checklist for [STACK]. 
README for [NAME] on [STACK]. 
System design doc for [SYSTEM].

Counts and formats are doing the heavy lifting. "Five entities" gives you a bounded answer; "a schema for a domain" gives you an unbounded one.

Lesson 2: the example output is an instruction you didn't have to write

Every prompt ships with a short example of what a good answer looks like. For the API prompt:

GET /api/users → 200 OK, list users (paginated, max 50/page) GET /api/users/:id → 200 OK / 404 Not Found POST /api/users → 201 Created / 400 Validation Error DELETE /api/users/:id → 204 No Content / 404

That example pulls the output format up into the prompt without adding a sentence of instruction. It also gives you a review surface: a draft is missing the response body or returns 200 for a delete, you know in seconds that it is not usable. I have stopped rewriting prompts from scratch and started reading drafts against a reference.

If you build prompts for a team, this is the part that survives handover. A colleague can see what "good" looks like from the example without you explaining your taste — and the format is also trivially scriptable if you want to machine-check a draft later.

Lesson 3: variables are the interface contract

The [RESOURCE], [DOMAIN], [STACK], [NAME], [SYSTEM], [DOMAIN_OBJECT] slots are not filler. They are the list of inputs the prompt genuinely requires, made explicit at write time. Writing the API prompt forced me to decide what the auth model was supposed to be, because there was a slot for it. Writing the schema prompt forced the decision about entity count. Both of those decisions are cheaper to make while designing the prompt than while reading five bad drafts.

There is a second-order benefit: an explicit slot list is the unit of hand-off. A prompt with visible variables can be given to somebody else with a one-line instruction ("fill the slots, paste, edit"). A prompt that says "design something for my service" cannot.

Lesson 4: placeholder hygiene is a security and correctness concern

The example outputs in the set contain illustrative values — sample IDs, sample endpoints, sample record counts. They show the shape of a good answer. They are not a specification.

Two habits I now enforce on any prompt set I write:

  1. Never let a sample value be mistaken for a decision. In the API example, GET /api/users is illustrative. If your resource is orders, the example's path shape is still instructive but the path is not a suggestion to keep.
  2. Review anything that reaches a system. These prompts produce drafts for humans to edit — a draft README, a draft PR description, a draft postmortem. They are not production config, not a substitute for a security review, and not a replacement for a senior engineer. The generated output can be confidently wrong, and in the regulated cases — legal, tax, medical, financial — a licensed professional reviews it before anyone relies on it.

What the outputs in this post are

The example outputs quoted here are AI-generated demonstrations of what a good answer looks like. They are not production code, not real incidents, not real pull requests, and not a benchmark. Nothing in this pack has been validated against a controlled study, and nothing in it guarantees any productivity gain, time saving, code quality improvement, income, revenue or promotion. These are drafting aids: they give you a starting structure, and the judgement stays with you.

Where it is available

The twenty prompts are in one file with a top-ten quick-reference card: https://aukawave8.gumroad.com/l/developer-productivity-pack — code DEVTO15 takes 15% off. MIT-licensed: use it, edit it, use it at work, use it commercially. You cannot resell the pack itself and you cannot present the prompts as your own authorship.

If you write prompts for engineering work, steal the structure rather than the content: name the artifact, carry a count or a format, ship a reference output, make the variables explicit, and treat every sample value as a placeholder until a human replaces it.

Written with AI assistance. The example outputs above are AI-generated demonstrations, not client case studies.

Full pack: 20 prompts, MIT licence — https://aukawave8.gumroad.com/l/developer-productivity-pack (use code DEVTO20 for 20% off).