Skip to main content

Use Viewfield in your codebase

Your brand does not have to live in a browser tab. Connect the MCP server inside the repo you are already working in (through Claude Code, Cursor or any MCP client) and run the copy in your codebase through your voice, your writing rules and the checks, without leaving your editor.

Say "review the docs with Viewfield" or "rewrite the landing copy using Viewfield", and your agent pulls the copy out of your files, sends it to Viewfield and writes the improved version back.

How it works​

The split is simple: your client owns the files, Viewfield owns the brand.

  1. Your agent reads the copy from your repo: a landing page, a README, docs, UI strings.
  2. It calls a Viewfield tool with that copy.
  3. Viewfield runs the text through the same brand context that writes every draft: your voice and dials, the words you never say, your writing rules, the rule for the kind, your docs, the checks and what they learned.
  4. Your agent writes the result back into your files.

Viewfield never reads your filesystem, and nothing is stored as a draft: it is a stateless pass through your brand.

Prerequisites​

  • Connect the MCP. Follow Install the MCP and Authentication. The key scopes every call to one workspace.
  • Fill Brand. The value comes from what Brand holds: at least your voice and rules, ideally your docs and proof. An empty Brand still runs, with thin context.

Once connected, ask your client to list the Viewfield tools; review_copy and revise_copy appear with their full schemas.

The two tools​

review_copy: read-only critique​

Reviews copy and returns findings without changing anything. For each segment you get:

  • slop: the checks' deterministic violations (the tells of AI writing, the words you never say, broken writing rules), with counts and samples.
  • findings: a critique against your brand: off-voice lines, anything that contradicts a rule or a learned preference.
  • suggestions: concrete directions.

Use it to audit a surface before you touch it. Your agent decides what to change; the rewriting belongs to revise_copy, so the words that land in your files come from your brand, not from the agent's own paraphrase of the findings.

"Review the copy in docs/ with Viewfield and summarize what is off-brand."

revise_copy: rewrite through the brand​

Rewrites copy in your voice and returns the improved version per segment, after the checks' lint-and-repair pass. Each result includes the original, the revised text, whether it changed, and the slop count before and after.

revise_copy preserves each segment's role and length and any Markdown, HTML or {{placeholders}}, so the result drops straight back into the same slot in your file. Pass an optional instruction to steer the pass ("tighten and make more benefit-led").

The returned revised text is the deliverable: apply it verbatim. An agent that rephrases, trims or "improves" the output on the way to the file reintroduces exactly the drift the brand exists to remove. If a segment comes back with a note saying it was not revised, retry it in a new call rather than substituting the agent's own rewrite.

"Rewrite all the copy on the landing page using Viewfield, then apply the changes."

Segments​

Both tools take a batch of segments (one per string or section), each with a stable id and its text:

{
  "surface": "the landing page hero",
  "segments": [
    { "id": "hero.title", "text": "The best content tool ever" },
    { "id": "hero.subtitle", "text": "We help you make amazing content fast" },
    { "id": "cta.primary", "text": "Get started now" }
  ]
}

The id is how each result maps back to its place in your file; use something stable and descriptive (hero.title, README#intro, a key path). Send a whole page's worth of segments in one call and Viewfield revises them coherently, as one surface. You can also pass a single text instead of segments, which is handy for one document.

Tell your agent how to segment: pull out the human-readable copy, keep code and identifiers out, and keep one logical string per segment.

Limits​

A single call accepts up to 40 segments, 8,000 characters per segment and 40,000 characters total; split larger jobs into batches (a page or a doc at a time works well). The two tools share a budget of 20 calls a minute per workspace, and both spend from the workspace's AI allowance. Optionally set platform (default blog, the right choice for websites, docs and product copy) to review against a specific kind's rule.

Cost​

review_copy and revise_copy spend from the workspace's allowance exactly like a draft in the app. They create no drafts; they are stateless transforms.

A typical loop​

"Review the landing copy in app/page.tsx with Viewfield, then rewrite whatever it flags and apply the edits."

Your agent reads the file, calls review_copy, sees the findings, calls revise_copy on the weak segments, and writes the returned text into the file verbatim: every line now shaped by your voice, your rules and the checks.

See the MCP overview for everything else the server can do.