Why I Wrote a Prompt Engineering Book

It started as a text file on my desktop called ai-notes.md.

I had been working in data engineering and solution architecture for over twenty years. I understood databases, distributed systems, business intelligence pipelines. When ChatGPT arrived, I expected it to fit somewhere into the technical mental model I already had. It did not.

The outputs were inconsistent in ways I could not predict. Sometimes a prompt that worked yesterday would produce something completely different today. Sometimes adding more detail made the response worse, not better. Sometimes a simple, casual phrasing outperformed a carefully structured one. I kept adjusting and re-running, but I didn't have a real model for why things worked or didn't.

The gap I couldn't find a resource to fill

I went looking for something systematic. What I found fell into two buckets.

The first was highly technical academic content about transformer architectures, attention mechanisms, training objectives. Correct, but not what I needed for daily use. Understanding the mathematics of how a language model predicts the next token does not directly translate into knowing how to write a better prompt.

The second was listicles: "10 ChatGPT prompts for marketers", "Top 50 prompts for productivity". Useful for copying and pasting. Not useful for understanding why those prompts worked, or how to write new ones that worked just as well in a different context.

What I wanted was something in between. A resource that built up a genuine mental model of how these systems behave, then connected that model to practical technique. Something that answered "why does adding a word limit produce a better summary" and "why does specifying the audience matter more than specifying the topic." Something with enough structure to feel teachable, but grounded enough in real use that it didn't collapse the moment you tried to apply it to your actual work.

I couldn't find it, so I started writing it myself. The text file grew.

What I actually learned

The shift that mattered most wasn't learning a new set of tricks. It was understanding what I was interacting with.

LLMs are not search engines. They don't retrieve answers from a database. They generate responses by predicting what a plausible continuation of your input looks like, given everything they were trained on. That sounds abstract, but it has very concrete implications for how you write prompts.

It means that context is not decorative. It changes what the model treats as the most plausible continuation. A prompt with no context gives the model maximum freedom to interpret what you want, and that freedom produces inconsistency.

It means that format instructions work best when placed before the task, not after. The model is building the response as it reads; telling it the format at the end means the structure was already decided before the instruction arrived.

It means that negative constraints ("do not include disclaimers") are often faster than positive instructions for fixing a recurring output problem. The model can't read your mind about what's annoying you; telling it what to avoid is more precise than trying to describe what you want instead.

None of these things are obvious from using the tool casually. Once I understood the underlying logic, prompt writing stopped feeling like guessing and started feeling like design.

What went into the book

By the time the notes had grown to a few dozen pages, I was sharing them with colleagues who were hitting the same walls. The feedback was consistent: they wished something like this had existed when they started.

I spent the next several months turning the notes into something more structured. I added the analogies that had helped me build intuition: the library analogy for how training data shapes responses, the chef analogy for the difference between standard programs and machine learning models. These came from Chapter 2 of the book, which covers how LLMs actually work at a level that's useful for prompting without requiring a background in machine learning.

I added exercises at the end of each section, because reading about techniques without immediately applying them meant they didn't stick. I added a troubleshooting section, because most of the questions I'd been asked came down to a small set of recurring problems.

The 250+ prompt templates in the appendix came last. They started as examples inside the chapters, and there were enough of them that it made sense to pull them into a standalone reference. Twelve categories, covering everything from creative writing to technical tasks to ethical prompting.

Who the book is for

I wrote it for the person I was at the beginning: technically capable, genuinely curious, frustrated by inconsistent results, and unable to find a resource that explained the underlying logic rather than just providing examples to copy.

That turned out to describe a wider audience than I expected. The reviews came in from data scientists, product managers, content creators, teachers, and people with no technical background at all. The through-line was the same: they wanted to understand the tool, not just use it.

The book starts with what prompt engineering is and builds through to advanced techniques. If you are working through the same learning curve I was, Practical Prompt Engineering is where I would tell you to start.