Connect Your Writing Style to ChatGPT Apps: Setup Guide

TL;DR: A ChatGPT app is a remote MCP server that ChatGPT can call in the middle of a conversation. Point one at a Style Profile built from your own writing and ChatGPT stops guessing at your writing style: it loads the profile, rewrites drafts in your voice, and checks a draft against your measured sentence length, comma rate and vocabulary variety. Setup is Developer mode, then chatgpt.com/plugins, then the MyWritingTwin OAuth URL. The same profile then serves Codex, the OpenAI API and any agent you build.

You wired ChatGPT into a workflow, gave it a real task, and the first draft came back reading like a press release. Correct, polite, and written by nobody in particular.

That gap is a data problem, and a ChatGPT app is the cleanest way to close it, because it lets ChatGPT read a profile of how you write instead of a paragraph about how you hope to sound.

What Is a ChatGPT App, and Why Does It Matter for Your Writing Style?

A ChatGPT app is an outside service that ChatGPT can call while it works, the same way it searches the web or reads a file you uploaded. For writing style, that means ChatGPT can fetch the real profile of how you write at the moment it needs it, instead of relying on whatever you pasted into a settings field months ago.

Under the hood these apps are remote MCP (Model Context Protocol) servers. OpenAI's developer documentation now groups them as plugins, where a plugin bundles an MCP server, optional skills and optional UI, and the Apps SDK is the toolkit for building one. Per OpenAI's connect and test guide, you add your own server from the Plugins page once Developer mode is on, and ChatGPT discovers the server's tools and metadata from there. Developer mode availability can depend on your account and workspace policy.

The MyWritingTwin server exposes two kinds of things to ChatGPT:

• A resource, mwt://profiles/current, holding your active Style Profile in system-prompt form. Clients that discover context through MCP resources can read it without a tool call.
• Tools to rewrite a draft in your voice, check a draft against your measured patterns, export the profile in several formats, and deposit new writing samples into your account.

That second list is what makes an app different from a settings page. The same server that serves a ChatGPT conversation also serves Codex, the Responses API, Claude, and any agent that speaks MCP. One profile, many consumers. If you build on ChatGPT, that is the property you were looking for.

Why Doesn't ChatGPT Know Your Writing Style Already?

Because nothing about you is in the model. ChatGPT is trained on public text and tuned to be useful to everyone, which makes its default voice the average of everyone. Model capability and user-data conditioning are separate layers: OpenAI keeps improving the first, and no lab can supply the second. Your emails are not in the training data, and a general-purpose model is not tuned to prefer them even if they were.

That is why the usual fix, telling ChatGPT to "write in a professional yet friendly tone", changes so little. "Professional yet friendly" describes thousands of people. A voice lives in sentence length, qualifier placement, transitions and punctuation. AI does not know your tone; it knows words that describe tone, and those words map to the same generic register for every user who types them.

A short comparison of what a label carries versus what a profile records:

The right-hand column is what a Style Profile stores, and it is what the app hands ChatGPT. We covered the extraction itself in how AI style extraction works; the short version is that the profile is evidence of how you write, not a hope about how you might sound.

One more point, because it decides whether this is worth doing at all. A better model does not make a personal profile less necessary. It makes the profile more valuable. The better ChatGPT gets at following nuanced instructions, the more faithfully it executes a precise profile. Every model generation narrows the execution gap and leaves the specification gap exactly where it was, since the specification has to come from your writing. When we profiled five AI models like human writers, each had a measurable house style. None of them matched a particular person, and none of them will, because that data is yours.

How Do You Connect Your Writing Style to a ChatGPT App?

Three steps: build the profile, add the MCP connection in ChatGPT, ask ChatGPT to use it. Budget fifteen minutes if you already have writing samples on hand, most of it waiting for generation.

Step 1: Build a Style Profile from your own writing

Create a free account and add writing you actually sent: emails, posts, reports, messages. Not AI drafts you edited, and not the writing you wish you produced. The profile models whoever wrote the text, so the samples have to be yours. The first use case is free with no card.

Generation takes 30 to 90 seconds. You get a Writing DNA analysis plus deployable exports: a Master Prompt, a Runtime Block in JSON for agents, and the system-prompt format the app serves. If you have not seen what a profile contains, start with what a Writing Style Profile is.

Step 2: Add the MCP connection in ChatGPT

1. In ChatGPT, open Settings, select Security and login, and turn on Developer mode.
2. Go to chatgpt.com/plugins and select the plus button.
3. Enter a name (MyWritingTwin) and a short description.
4. Under Connection, enter the MCP server URL: https://www.mywritingtwin.com/api/auth/mcp
5. Create the connection. ChatGPT opens a MyWritingTwin sign-in screen (OAuth 2.1). Approve it and the connection is live.
6. Review the tools ChatGPT discovered. You should see the rewrite, check, profile and sample tools listed.

Use the address ending in /api/auth/mcp. It is the endpoint that asks you to sign in, and it publishes the OAuth metadata ChatGPT looks for. OpenAI's authentication guide describes that flow: ChatGPT reads the server's protected-resource metadata, registers itself as a client, and runs an authorization-code exchange with PKCE. MyWritingTwin supports dynamic client registration and PKCE, so no manual client setup is needed on your side.

Step 3: Ask ChatGPT to use it

Start a new conversation, add the MyWritingTwin connection from the tools menu, then ask in plain language:

• "Load my writing profile and rewrite this in my voice: [paste draft]"
• "Check this draft against my profile and tell me which constraints fail."
• "Draft a reply to this thread in my client-email mode."

ChatGPT picks the right tool from the request. You do not need to name the tools, though it helps to know what they do.

What Can ChatGPT Do Once the Profile Is Connected?

Six tools carry most of the work. The table lists what each one does and when ChatGPT reaches for it.

The one worth understanding is mwt_check_draft. ChatGPT's own opinion on whether a draft matches your voice is not trustworthy. We measured assistants inventing passing numbers, then drifting further from target on each revision, so the check runs as real code on our server and returns the actual numbers. If a constraint fails, ChatGPT revises and checks again, and stops when everything passes. A self-report cannot be faked into that loop.

Modes are the other feature to know. A profile is a matrix of language, audience and medium, and the app can serve a single cell of it. Your client emails and your team Slack messages are different registers, and ChatGPT should get the one you asked for, not a blend. The ChatGPT platform page has the shorter version of all this if you want to send it to a colleague.

How Is This Different From Custom Instructions, Projects or a Custom GPT?

Custom instructions, Projects and custom GPTs are containers. The app is a source. All of them are worth using, and they do different jobs.

Our guide to making ChatGPT sound like you walks through custom instructions and Projects in detail, and that setup still works. The limit is what those containers hold. A Project holds a description you wrote yourself, with the blind spots self-description always has. You describe the writer you want to be, and you cannot see the patterns you produce on autopilot. Knowledge files raise the ceiling a little; we measured where that ceiling sits, and it sits well below a measured profile.

There is also a structural difference. A Project is a session; a profile is an asset. A description typed into ChatGPT stays in ChatGPT. A profile you own can be exported as a Runtime Block and dropped into Claude, Gemini, a Cursor rule or your own agent. If you already run the Claude connector, it reads the same profile as the ChatGPT app, so a regeneration on one side shows up on both. The app does not replace your Project. Paste the profile export into the Project instructions if you like, and keep the app for what static text cannot do: check and rewrite against measured constraints, and stay current when you regenerate.

What About Codex, the API and Agents You Build?

Same server, different auth. Create an API key on your dashboard and register https://www.mywritingtwin.com/api/mcp as a remote MCP server with an Authorization: Bearer mwt_sk_... header. That endpoint never prompts for a login, which is what you want in an unattended agent.

Where it plugs in:

• Codex speaks MCP, so the same server registration gives every Codex session the rewrite and check tools. Your agent's pull-request descriptions and commit messages can read like you wrote them, and the check tool tells you when they do not.
• The Responses API accepts a remote MCP server as a tool. Pass the server URL and the bearer header, and an agent you build can call mwt_get_profile at startup, write in the returned system-prompt format, and run mwt_check_draft before it sends anything.
• Anything else that speaks MCP, from Claude Code to a Cursor rule, uses the same key and the same URL.

The full reference, including the REST endpoints behind the tools, is in the API documentation. If you would rather not maintain a live connection, export the Runtime Block once and ship it inside the agent's system prompt; you lose the measured check, and you keep everything else.

What Should You Check When the Output Still Drifts?

Run the check instead of rereading the draft. Most drift has one of four causes, and each has a fix that takes a minute.

1. Wrong mode. Ask for the register you need by name: "use my client-email mode". A blended profile reads flatter than any single cell.
2. ChatGPT eyeballed it. Ask it to run mwt_check_draft and show the table. A failing constraint is a specific instruction; "sounds a bit off" is not.
3. Thin samples. If the failing constraints cluster in one medium, deposit more of that medium with mwt_import_samples and regenerate. The profile is only as wide as the writing behind it.
4. The connection is off. MCP connections are enabled per conversation from the tools menu. If ChatGPT answers from memory, check the toggle, and if the tool list looks stale after a regeneration, open the connection on the Plugins page and select Refresh.

Then the honest limit. A profile constrains rhythm, vocabulary, punctuation and structure. It carries no opinions and no facts. ChatGPT will write the paragraph the way you write paragraphs, and you still have to tell it what the paragraph says. Anyone who promises that a style layer makes the content yours as well is overselling.

What to Do Next

1. Build your free Style Profile from writing you actually sent.
2. Turn on Developer mode, add the MCP connection at chatgpt.com/plugins with the OAuth URL above, and confirm the sign-in screen appears.
3. Run one real draft through mwt_rewrite_in_voice, then mwt_check_draft, and read the numbers.
4. If you build on Codex or the API, register the same server with an API key and stop maintaining a voice prompt in every repo.

Apps are the first ChatGPT surface where your writing style can live outside the chat and be read on demand. Your Writing Twin for ChatGPT, Claude, Gemini and any MCP agent is one profile, built once, and the app is how ChatGPT reads it.