How to Teach an AI Agent to Write in Your Voice

The most common way to teach an AI agent your voice is to give it a stack of your texts and say “copy my style.” It doesn’t work. Or rather, it works - but it gives back not you, but an average author who looks like you from far away. I went through this on my own texts, and I want to break down why it happens and what to do instead.

One note up front: this is not about a “secret prompt.” It’s about the fact that voice is a stubborn thing, and it does not transfer the way everything else transfers when you work with agents.

Why “copy my style” doesn’t work

I started with the obvious thing: I gave the agent 11 of my old posts and asked it to pull out my style. It worked - but it wasn’t me. The agent gave back a generic “woman blogger” voice: “sharing my thoughts,” “dear friends,” smooth transitions, a neat little conclusion at the end of every paragraph.

This is not the agent being dumb. It’s the math of the model. When you ask it to “describe the style of these texts,” the model reaches for the center - for the most likely, most average way to write something similar. But voice does not live in the center. Voice is the deviations from the average that make a text recognizable. Automatic extraction smooths exactly those, because its job is to find what’s common, not what’s specific.

Here is the takeaway worth remembering: the more “correctly” the agent extracts the style on its own, the further it gets from you. Averaging and individuality pull in opposite directions.

Voice lives in the micro-details

When I started to look at what my voice is actually made of, it turned out to be made of small things - things that are easy to miss and even easier to “tidy up.”

• Brackets that comment on themselves.
• A sharp turn to a new topic with no connector - just the next paragraph about something else.
• A stop instead of a neat ending.
• :-))) at the end of the self-irony, not at the start of the sentence.

I tested this by deletion. Remove the brackets - and it’s not me anymore. Add a smooth transition between paragraphs - not me. Add a summing-up conclusion at the end - definitely not me. My voice turned out to be the sum of small wrong things, and an editor would clean out each one of them first.

That’s exactly why automatic extraction fails: it cleans out the very thing the voice stands on. And text “improvers” do the same - they turn you into a smooth nobody.

The method: you write, the agent learns from your edits

Once it was clear that one command won’t do it, we went the other way. The method that works is the reverse of what I tried first - and it repeats.

The cycle is this:

1. First I write the text myself - as it comes, a flow of thoughts. Not polished, but it’s my material and my thought, not the agent’s retelling.
2. The agent cleans it up - puts it in order, but tries to stay in my style, based on what it already knows about me.
3. I edit its cleaned-up version. I put back what is mine where it replaced me: I remove the smooth transition, I put the abrupt stop back, I return the bracket in the middle of the thought.
4. And the main step - I tell it: remember how I rewrote your phrases. Not “write more lively,” but specifically: here was your wording, here is my edit - catch the difference and write down a rule.
5. The rule goes into a separate file - a skill the agent reads before every text. Next time it cleans up closer to me, and I have to edit less.

The whole point is in step four. The agent learns not from my finished texts (there it only guesses and averages), but from the difference between how it wrote and how I rewrote it. My edit is the cleanest signal: it shows the exact spot where it missed me. In a finished text that spot is invisible; in an edit you see it right away.

This is slower than one command. But this is the case where slow is the only way to get it right.

A strange side effect: you see your own voice from outside

There was an unexpected moment. When your voice slowly turns into a set of rules - built on your own edits - it is like looking at yourself from outside. You write a certain way for years and don’t know how it’s built. And then suddenly you see it clearly: this I do, this I don’t, and here is why.

This is useful not only for the agent. When your voice is laid out as rules, you start to write more consciously yourself - you see where the inertia of “how it’s normally done” replaces you, and you come back to yourself. Calibrating the agent quietly calibrates you too.

The learning goes both ways

Here I should say something about the second half of the process, the part people usually miss. We are used to thinking that we are the ones teaching the agent. But the learning goes both ways.

When I was building my first agent system, I found a detailed guide - dozens of pages, for beginners. Before, I would have had to read the whole thing. Now it’s simpler: you give the agent that same document, or a course transcript, or any over-complicated manual, and you ask it not to “explain how sub-agents work,” but specifically - “help me build this thing, by this guide, for my task.”

And it leads. It translates the documentation into human language, adjusts to your pace, remembers where you got stuck, comes back to what didn’t land the first time. That’s how I built a whole system without reading the manuals - by talking to a tool that already knows those manuals better than me.

Guides are useful. But the best way to learn a complex tool is to let it teach you, on your project, at your pace. You get a loop: the agent teaches you the tool, you teach the agent yourself. Two-way calibration, not one-way setup.

What transfers, and what doesn’t

And the last thing - the most important one, I think. One day I asked my agent whether I could take a design system I had built for one project and make a personal one out of it. I expected a “yes/no, here’s what transfers.” Instead it went and built it.

It read the system, took the methodology, threw out everything that was tuned for sales, kept the skeleton: agent roles, checks, structure. The architecture moved over in a minute. And then it hit the one thing it had nowhere to copy from - me. My colors, my fonts, my style. So it went into my old website and pulled the exact colors and fonts straight out of the live CSS - not by eye, from the code. And along the way it caught something I would have noticed only on a finished layout: the heading font had no Cyrillic, which means my Russian headings simply wouldn’t render. It found a twin font with Cyrillic.

Here is what stays with me in this whole story. What transfers is the architecture. What doesn’t transfer is who you are. And the second one matters more.

This is exactly the reason to bother with voice seriously. In a world where an agent copies any system, methodology, and structure in a minute, the only thing that stays only yours is your own voice and who you are. The more powerful the tools get, the more valuable the thing they can’t guess. An hour spent calibrating your voice pays back more than any automation, because what gets automated is the common, and what is valued is the specific.

If you want to repeat it

Short, step by step:

1. Don’t ask the agent to “extract the style” from finished texts - it will average you out.
2. Write the draft yourself, as a flow of thoughts. It’s your material and your idea.
3. Let the agent clean it up - but in your style, based on what it already knows about you.
4. Edit its version: put back what is yours where it replaced you.
5. Tell it “remember how I rewrote this” - and ask it to save a rule from the difference between its phrase and yours.
6. Keep the rules in a separate file the agent reads before working. Each time you edit less.
7. Protect the micro-details - the brackets, the abrupt stops, the missing smooth transitions. The voice lives in them.
8. Remember: the architecture the agent copies on its own. The voice - only with you.