Why I Stopped Prompt Engineering and Built a Principled AI Agency Instead

Here is the conclusion, up front: prompt engineering has a structural ceiling, and most enterprise AI deployments are already hitting it. The solution is not better prompts. It is codified professional identity; binding standards, enforced deterministically, accessible to any AI agent through a standard protocol. I built a working example. This post explains how, and why it matters well beyond copywriting.

Large language models produce competent text. They do not produce principled text.

When an AI drafts a headline, it draws on statistical patterns across billions of documents; not on a rigorous hierarchy of professional standards. The output may be plausible. It is rarely authoritative. Sentences drift into passive voice. Arguments bury the lead. Australian English gives way to American spelling without warning.

For a casual blog post, these are minor irritants. For enterprise communication (board papers, strategic proposals, change management programmes targeting tens of thousands of employees) they are credibility risks. A poorly structured business case does not just fail to persuade. It signals to senior stakeholders that the thinking behind it is equally loose.

I sit at the intersection of human resources and enterprise technology strategy in my day job. In this context, the integrity of written communication is not incidental to the work. It is the work.

So I set out to answer a specific question: can an AI tool hold a binding professional identity; not just follow general instructions?

The answer is yes. The mechanism is the Model Context Protocol.

Here is the problem with prompt engineering as an enterprise strategy.

The Old Way - Prompt Engineering: You craft careful instructions. You ask the AI to follow your style guide, use active voice, write for a senior executive audience. The model interprets those instructions. It applies them inconsistently. It forgets constraints across sessions. When instructions are ambiguous, it defaults to its training distribution; which is not your organisation’s voice, your industry’s standards, or your communication framework.

The New Way - Codified Professional Identity: You build a Model Context Protocol server. You extract authoritative professional standards from primary sources. You codify them into typed data libraries with deterministic validation logic. The AI does not interpret your standards. It enforces them, automatically, on every output, across every session.

This is not a marginal improvement in output quality. It is a different architectural model for how professional AI tools operate.

Anthropic developed the Model Context Protocol (MCP) as a standard interface for connecting AI agents to external tools, resources, and data sources. Think of it as a universal adapter. Any MCP-compatible host (Claude Desktop, Cursor, or a custom agentic workflow) connects to an MCP server and immediately accesses whatever capabilities that server exposes.

Most MCP servers expose utility functions: web search, database queries, code retrieval. This project takes a different position. Rather than exposing utilities, it exposes an entire creative discipline as a context-aware professional service; one governed by a binding hierarchy of thirteen professional authorities.

The server does not instruct the AI to write better. It provides the AI with codified, authoritative rules and enforces them deterministically through typed validation logic. The distinction matters: instructions can be forgotten or overridden; codified rules cannot.

The most important architectural decision in this project was not technical. It was editorial.

Rather than allowing the AI to reason about style from first principles, the server enforces a seven-tier authority hierarchy codified in a source document that governs every tool output:

When sources conflict, the hierarchy resolves deterministically. Strunk & White always prevail on matters of style. On advertising, Ogilvy governs brand communication; Hopkins governs direct response. The rules for conflict resolution are explicit, not inferred, and not subject to the AI’s judgement on the day.

Australian English is enforced throughout. Not at the AI layer, which no prompt reliably controls, but at the knowledge layer. Every data library, audit rule, and resource description uses Australian English. The standard takes hold through example and instruction, not through hope.

The server exposes nine tools across two categories: generation and auditing.

generate-copy accepts a strategic brief (product, audience, goal, and preferred framework) and returns structured copy conforming to a specified formula. Supported frameworks include AIDA, PAS (Problem–Agitation–Solution), BAB, FAB, and PPPP.

generate-headline applies Robert Bly’s headline taxonomy to produce variations across eight professional types: Direct, Indirect, News, How-To, Question, Command, Reason-Why, and Testimonial. It enforces Ogilvy’s 80 Cent Rule: the headline is the primary conversion lever in any piece of copy.

rewrite-copy accepts existing copy and a target framework, restructures the content according to that framework’s architecture, and returns both the revised copy and a Changes & Rationale section explaining the rhetorical shift.

copy-optimiser applies Bly’s 4 U’s framework (Urgent, Unique, Ultra-Specific, and Useful) to generate a conversion score and headline variations.

Here is where the server becomes genuinely distinctive. Rather than producing more text, the audit tools evaluate text against professional benchmarks, enabling the AI to operate as a credentialled creative director rather than a prolific typesetter.

analyse-copy evaluates copy against Aristotle’s three rhetorical appeals (Ethos, Pathos, Logos) and returns a six-section structured critique: framework alignment, rhetorical balance, readability, strengths, improvement recommendations, and an overall assessment.

style-audit checks copy against Strunk & White and the Australian Government Style Manual (AGSM). It flags passive voice, excessive sentence length (the AGSM ceiling is 25 words average), clutter words, and non-Australian spellings. Every finding carries a severity rating (warning or suggestion) and a specific remediation recommendation.

logic-audit evaluates structural integrity using the Minto Pyramid Principle and scans for informal logical fallacies using Grayling’s taxonomy (Straw Man, False Dichotomy, Hasty Generalisation, Slippery Slope). It specifically tests whether copy leads with the conclusion and whether the SCQA narrative (Situation, Complication, Question, Answer) is complete.

awareness-audit is the most strategically sophisticated tool. It accepts copy and the intended level of market awareness, drawn from Eugene Schwartz’s five-stage model in Breakthrough Advertising, and evaluates whether the messaging strategy is correctly calibrated. An Unaware audience requires storytelling and pattern interruption. A Most Aware audience needs price, incentive, and a clear path to act. Messaging the wrong awareness level is one of the most common and costly errors in enterprise communication.The tool simultaneously audits for WCAG 2.1 accessibility compliance: sentence length, complex word density, and reading grade level.

ux-audit audits digital copy for scannability based on Nielsen Norman Group research and CXL’s conversion principles. It flags paragraphs exceeding 60 words, checks heading density, evaluates bolding frequency, and identifies momentum phrases; the “bucket brigades” that sustain reading engagement across long-form content.

The technical stack is intentionally minimal: TypeScript with ESM modules, Node.js, the MCP SDK (@modelcontextprotocol/sdkv1.29+), and Zod v4 for strict input schema validation. The current build runs locally via StdioServerTransport, communicating over stdin/stdout - the right choice for a localhost deployment connected directly to Claude Desktop.

One constraint worth noting for practitioners. The StdioServerTransport layer reserves stdout exclusively for protocol communication. Using console.log() for debugging (a reflex for most developers) corrupts the protocol stream. The server routes all diagnostic output to stderr via a dedicated logger. This is a production-grade architectural constraint, not a development convenience.

The public release will move to a containerised deployment. The planned stack replaces the stdio transport with HTTP + Server-Sent Events (SSE) (the MCP specification’s standard transport for remote servers) served from a Docker container behind a reverse proxy (probably Nginx). This satisfies the MCP spec’s remote server requirements: a persistent HTTP endpoint for client connections, SSE for server-to-client streaming, and standard POST for client-to-server messages. The shift from local to public changes the transport layer only; the tool logic, data libraries, and authority hierarchy remain identical.

The build followed a data-first discipline. Before writing a single line of tool logic, I extracted all professional principles from the thirteen source authorities and codified them into typed data libraries in src/lib/. Each library (style-guide-data.ts, logic-data.ts, copywriting-data.ts, direct-response-data.ts, digital-data.ts) links every rule back to its source authority and tier via trace comments.

In short: the intelligence of this server lives in its data, not its algorithms.

One more thing worth stating plainly. This was not a lofty engineering project. I built the working local version in half a day - on a Saturday. Total cost: zero dollars. The MCP protocol is open source, the SDK is free, and the toolchain (Node.js, TypeScript, Zod) costs nothing. This is not blue-sky idealism about what AI might one day enable. It is a working system, built over a weekend, by a practitioner with a domain problem to solve.

Validation used Anthropic’s MCP Inspector (npx @modelcontextprotocol/inspector), which provides a web interface for invoking tools directly and inspecting raw JSON-RPC responses. Each tool underwent three test passes: compliant inputs to verify expected output structure; non-compliant inputs to verify Zod validation produces clear error messages; and edge cases to verify graceful degradation.

Final integration with Claude Desktop required a single JSON configuration entry:

{
  "mcpServers": {
    "copywriting-agency": {
      "command": "node",
      "args": ["/path/to/dist/index.js"]
    }
  }
}

From that point, every Claude Desktop conversation accesses the full agency, silently, without additional prompt engineering.

Let me be direct about the broader implication, because it extends well beyond copywriting.

Prompt engineering is not a strategy. It is a workaround. A general-purpose model interprets instructions. It does not enforce them. It forgets them across sessions. It drifts from them when context is ambiguous. For personal productivity, that is manageable. For enterprise communication at scale (where hundreds of contributors produce content that represents your organisation’s intelligence and credibility) it is a governance gap.

MCP servers close that gap. Here is the mechanism:

• Deterministic enforcement: Standards execute as code, not as suggestions

• Session persistence: The professional infrastructure is always present, regardless of who initiates the conversation

• Scalable consistency: Every user, every output, every time

For HR technology leaders specifically, the opportunity is substantial. Workforce communication at enterprise scale (policy documents, change management materials, executive briefings, onboarding content) is currently produced inconsistently, by contributors of variable skill, and rarely audited against professional standards. An MCP server does not replace human judgement. It provides the standards against which that judgement is measured and enforced.

The copywriting server I have built is, in one sense, a narrow application. In another sense, it is a proof of concept for a principle with much wider reach: any codified professional discipline can become an AI-accessible service. Legal drafting standards. Financial communication guidelines. HR policy frameworks. Safety documentation protocols. Each can be extracted, codified, and enforced, automatically, on every output, by any AI agent with an MCP connection.

That is not a future capability. It is available today.

The immediate next step is rebuilding for docker and public accessibility so I’m not running this on my laptop. I’m not looking to “productionise” this proof of concept learning project, so I’m not going to extend the capability any further.

If you are exploring MCP development for your own practice or organisation, Anthropic’s documentation is the right starting point. The MCP Inspector makes iterative testing straightforward, and the TypeScript SDK enforces enough discipline to keep a solo build production-grade.

If you have built something similar, or are thinking about it, I would welcome the conversation. The most interesting applications of this technology will come from practitioners who bring deep domain expertise, not from technologists working from the outside in.

This post was initially drafted from a technical brief prepared during the build, then audited using the copywriting-agency MCP server tools (style-audit, logic-audit, awareness-audit, and ux-audit) before refinement and final revision for publication. All copywriting-agency findings were incorporated into the final version.