The Taste Artifact

Your codebase is a classroom. You've been writing the curriculum unconsciously.

Here's the most effective way to get a coding agent to write good tests: put it in a project that already has good tests.

Not instructions. Not prompts. Not a carefully worded description of what "good" means. Just the existing test suite—organized, patterned, reflecting your preferences. The agent reads the room. It absorbs what's there and produces more of it.

Simon Willison, describing how experienced engineers work with AI tools: "Keeping your test code well organized and populated with patterns you like is a great way to help your agent build testing code to your taste."

The Teaching You Didn't Know You Were Doing

Every codebase teaches. The patterns in your code—naming conventions, file structure, test organization, error handling style—aren't just decisions you made. They're lessons your agents absorb.

When the agent lands in your project, it doesn't start from zero. It reads. It infers structure from what exists. If your tests use fixtures consistently, the agent writes fixtures. If your tests are scattered and inconsistent, the agent scatters and inconsists. The codebase is the curriculum whether you designed it to be one or not.

This means you've been teaching already. Every shortcut you left in place, every well-structured test, every messy compromise—it's all instruction. The agent doesn't distinguish between "this is my best work" and "this was quick and dirty." It reads the environment as-is and produces more of what it finds.

The question isn't whether you're teaching. It's whether you're teaching what you mean to.

The Verb Change

Code quality used to be aesthetic. Clean code was a professional choice. You organize your tests because it's professional. You maintain consistent patterns because it's satisfying. The motivation is craft—doing good work because good work matters.

Now there's a second function. Your test suite isn't just a quality artifact. It's a teaching artifact. The patterns you curate don't just reflect your taste—they transmit it. Every agent session inherits the standards embedded in your codebase, without being told.

Curation becomes pedagogy. The hour you spend refactoring a test file isn't cleanup—it's lesson planning. You're shaping the environment your next collaborator will learn from.

And here's what makes this compound: the agent's output becomes part of the environment too. Good tests beget good tests. The agent absorbs your patterns, produces code that reflects them, and that code becomes new material for the next session to absorb. Taste reproduces itself when the environment is well-curated.

Neglect reproduces itself too.

Tests as Input, Not Just Output

One frame says: tests are the deliverable. You write the specification, define the expected behavior, and let the agent generate the implementation. The tests are what you ship. The code is commodity labor.

That's a real insight. But "The Taste Artifact" is a different move. Here, tests aren't the output you produce—they're the input that shapes production. You're not shipping tests to define what should be built. You're curating tests to shape how building happens.

Same artifact, different verb. One is about what you deliver. The other is about what you cultivate.

Cultivation changes where you invest. If tests are output, you invest in writing better specifications. If tests are input, you invest in curating better examples. The first is a writing problem. The second is an environment design problem.

What You're Actually Curating

Willison identifies the deeper skill: "Developing good taste in testing code is another of those skills that differentiates a senior engineer."

Taste. Not knowledge—taste. The word matters.

Knowledge is explicit. You can document it, transfer it, explain it in a prompt. Taste is implicit. It's embedded in choices you make without articulating why. The fixture pattern you prefer. The naming convention that feels right. The level of abstraction that strikes the balance between readable and maintainable.

You can't prompt an agent into taste. Taste doesn't transfer through instruction—it transfers through example. Through environment. Through the accumulated decisions that make a codebase feel coherent rather than assembled.

This is why curation compounds and prompting doesn't. A prompt is consumed once and forgotten. A curated environment persists across every session. The instructions disappear between conversations; the codebase stays.

The Infrastructure Decision

Here's the practical reframe: the next time you're about to write a detailed prompt explaining how you want tests structured, stop. Instead, spend that time refactoring one existing test file to reflect your actual preferences.

Not all your tests. One file. Make it exemplary. Make it the thing you'd show a new hire and say "write tests like this." Then let the agent work in that codebase.

You'll have done something a prompt can never do: you'll have embedded your taste in the environment itself. Not described it—demonstrated it. And that demonstration persists. Every future session inherits it. Every agent output that matches the pattern reinforces it.

One test file, curated well. That's the taste artifact. And it teaches long after you close the editor.

The codebase is the classroom. The tests are the curriculum. Curate once, compound forever.

Sources: Simon Willison — 'Your job is to deliver code you have proven to work' (December 2025) + 'Vibe Engineering' (January 2026)