Forget Prompt Engineering: The 3% of Claude That Actually Ships Work

By Lazar Milicevic · Published June 8, 2026 · 8 min read

If you're paying for Claude and still copy-pasting between five browser tabs, you've been sold the wrong feature. Prompt frameworks, mega-prompts, chain-of-thought tricks — none of it moves work through your business. Two features do: MCP and Skills. Here's the exact setup I run for invoicing and lead-gen clients, and why it kills 90% of the prompt engineering content you've been reading.

MCP in plain English: the wire between Claude and your tools

Forget the spec sheet. MCP (Model Context Protocol) is the cable that lets Claude reach into your actual tools — Gmail, Postgres, Stripe, Telegram, your filesystem — and do things. Not describe things. Not draft an email you then send. Actually send it. Actually query the production database. Actually generate the invoice PDF and attach it.

The difference between "Claude in the browser" and "Claude on MCP" is the difference between an intern who writes great memos and a junior employee who closes tickets. The intern is impressive at a demo. The junior actually clears your inbox.

That's why I tell every client the same thing: if Claude isn't connected to at least your inbox, your database, and your file system, you're paying $20/month for a fancy autocomplete.

The six MCP servers I wire into one Claude instance

This is the stack I deploy for a typical small-business client. One Claude, six servers, one JSON config file. Everything runs on a ~€400 mini PC under my desk — no cloud bill, no per-seat SaaS tax.

• Gmail MCP — reads inbox, classifies messages, drafts replies, sends directly for trusted senders
• Postgres MCP — queries the production lead DB, scores leads by recency and source, pulls top 10 for outreach
• Filesystem MCP — reads/writes inside a sandboxed project folder (templates, generated PDFs, CSV exports)
• Telegram MCP — pushes approval prompts to the founder's phone, accepts replies
• Stripe MCP — checks payment status, issues refunds when conditions match, reconciles paid invoices
• Custom Serbian e-invoicing MCP — submits to the tax authority API and validates response (the stuff no off-the-shelf tool covers)

The config that wires them up is unglamorous on purpose:

{
  "mcpServers": {
    "gmail": {
      "command": "node",
      "args": ["/srv/mcp/gmail-mcp/dist/index.js"],
      "env": { "GMAIL_CREDENTIALS": "/srv/secrets/gmail.json" }
    },
    "postgres": {
      "command": "uvx",
      "args": ["mcp-server-postgres", "--dsn", "postgres://claude_ro@localhost/leads"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/srv/clients/acme"]
    },
    "telegram": {
      "command": "python",
      "args": ["-m", "telegram_mcp"],
      "env": { "TG_BOT_TOKEN": "***", "TG_CHAT_ID": "***" }
    },
    "stripe": {
      "command": "node",
      "args": ["/srv/mcp/stripe-mcp/dist/index.js"],
      "env": { "STRIPE_KEY": "***" }
    },
    "einvoice": {
      "command": "python",
      "args": ["/srv/mcp/einvoice-rs/server.py"]
    }
  }
}

That's the whole "stack." No Kubernetes, no orchestrator, no $400/month "AI platform" subscription. Six processes, one config.

Skills: the playbook layer that retires your prompt folder

A Skill is a reusable instruction file Claude loads on demand when the task matches. Instead of pasting a 2,000-word system prompt every time, you write the logic once, save it as a Skill, and Claude pulls it in.

One client setup has 4 Skills replacing roughly 1,200 lines of prompt boilerplate. Same output. Zero copy-paste.

Concrete example — the invoicing Skill for a Serbian VAT-compliant invoice:

• Before Skills: ~8 minutes per invoice. Claude needed the customer record, tax rules, formatting template, e-invoicing payload spec, totals sanity check — all glued together in a brittle mega-prompt.
• After Skills: ~40 seconds end to end. ~90 lines of structured instructions with examples. Fully compliant. Zero manual review for standard cases.

The Skill file itself looks like this:

---
name: invoice-serbian-vat
description: Generate a VAT-compliant invoice for Serbian clients, submit to e-invoicing API, attach PDF to email reply.
---

# When to use
Trigger when the user (or an inbound email) requests an invoice for a Serbian client.

# Required inputs
- customer_id (lookup via postgres MCP, table `customers`)
- line_items (description, qty, unit_price_eur)
- service_date

# Steps
1. Query postgres: SELECT tax_id, address, vat_rate FROM customers WHERE id = $1
2. Compute totals. VAT = subtotal * vat_rate. Round HALF_UP to 2 decimals.
3. Build e-invoice XML payload (schema: UBL 2.1, see examples/ubl_example.xml)
4. Submit via einvoice MCP -> capture returned UUID
5. Render PDF via filesystem MCP using template templates/invoice_rs.html
6. Reply to original email via gmail MCP, attach PDF, CC accounting@

# Examples
[3 worked examples with sample inputs + expected outputs]

That's it. Claude reads this when the task matches, orchestrates the MCP calls itself, and you get a sent invoice. Your "prompt" from the user side is now three lines: "Invoice the email from Marko for the November consulting work, 12 hours at €80."

The combo move: one minute, zero human input

Here's the choreography nobody is showing you. A customer email lands in Gmail.

• Gmail MCP surfaces it → Claude classifies it as an invoice request
• Claude loads the invoice-serbian-vat Skill
• Postgres MCP returns the customer's tax ID, address, VAT rate
• Custom e-invoicing MCP generates the UBL payload and submits to the tax authority
• Filesystem MCP writes the rendered PDF to /srv/clients/acme/invoices/2024/
• Gmail MCP composes a reply with the PDF attached, sends from the founder's address
• Telegram MCP pings the founder: "Invoice #2024-0412 sent to Marko, €1,152 incl. VAT, e-invoice UUID confirmed."

Total elapsed time: under 60 seconds. Total human input: zero. That is the 3% of Claude that matters. Everything else is a YouTube thumbnail.

What to ignore (and what to build instead)

If you take one thing from this post, take this list:

• Ignore mega-prompts. Once you have Skills, your user-facing prompts are 1–3 lines because the Skill carries the weight.
• Ignore 57-step prompt frameworks. They're content marketing, not infrastructure.
• Ignore "Claude in the browser" demos that don't connect to your tools. That's a toy. The leverage is in the wire.
• Ignore SaaS wrappers that charge you $99/month to do what 200 lines of Python MCP server does for free.

What to build instead: identify the one weird workflow in your business that no SaaS covers — your country's e-invoicing format, a custom CRM, a niche shipping carrier's API. Wrap it in an MCP server once. Claude can use it forever.

The Python MCP SDK is maybe 200 lines for a basic server. A minimal skeleton:

from mcp.server.fastmcp import FastMCP
import httpx

mcp = FastMCP("einvoice-rs")

@mcp.tool()
async def submit_invoice(xml_payload: str) -> dict:
    """Submit a UBL 2.1 invoice XML to the Serbian tax authority API."""
    async with httpx.AsyncClient(timeout=30) as client:
        r = await client.post(
            "https://efaktura.mfin.gov.rs/api/publicApi/sales-invoice/ubl",
            content=xml_payload,
            headers={"ApiKey": os.environ["EFAKTURA_KEY"]},
        )
    return {"status": r.status_code, "uuid": r.json().get("PurchaseInvoiceId")}

@mcp.tool()
async def check_status(invoice_uuid: str) -> dict:
    """Check submission status for a previously submitted invoice."""
    # ... 15 more lines
    ...

if __name__ == "__main__":
    mcp.run()

That's your escape hatch from the platform tax. You don't need to be a senior engineer to write this. You need an afternoon.

Why bizflowai.io helps with this

This is exactly what I build for clients at bizflowai.io: an MCP + Skills setup wired into your real tools — Gmail, your database, Stripe, Telegram, plus a custom MCP server for whatever workflow your country/industry has that no SaaS covers. Most builds run on a small home server or a €5/month VPS, so there's no recurring platform fee. The deliverable is a working system that closes the loop end-to-end, not a prompt library you have to maintain.

Frequently asked questions

What is MCP (Model Context Protocol)?

MCP, or Model Context Protocol, is the connection layer that lets Claude reach into real business tools like Gmail, Postgres, Stripe, Telegram, and the file system to actually perform actions — not just describe them. Instead of drafting an email you then send, Claude sends it. Instead of suggesting a database query, it runs it. MCP is effectively the wire between Claude and your business systems.

What are Claude Skills and how do they work?

A Claude Skill is a reusable instruction file — a focused playbook Claude loads on demand when a task matches. Instead of pasting a 2,000-word system prompt every time, you write the logic once, save it as a Skill file, and Claude pulls it in automatically. In one client setup, four Skills replaced roughly 1,200 lines of prompt boilerplate while producing the same output.

Why does combining MCP and Skills matter for small businesses?

Small businesses typically lose two to four hours daily to email triage, invoice generation, and lead follow-up because tools don't talk to each other. ChatGPT and browser-based Claude draft text but can't move data between systems. MCP closes that gap by connecting Claude to real tools, and Skills make the workflows repeatable instead of one-off prompts that break.

How do I set up multiple MCP servers with Claude?

You point Claude Desktop or Claude Code at each server's binary using a single JSON config file. Each MCP server runs locally or on a small home server — a typical setup uses six servers (Gmail, Postgres, Filesystem, Telegram, Stripe, and custom servers) running on a roughly 400-euro mini PC. There's no cloud bill or per-seat SaaS cost involved.

How much time can Skills save on repetitive tasks like invoicing?

In one real example, generating a VAT-compliant invoice took about eight minutes per invoice using a giant brittle system prompt covering customer records, tax rules, templates, and e-invoicing specs. After moving the logic to a Skill file of roughly 90 lines of structured instructions, invoice generation dropped to 40 seconds end-to-end with the same compliant output and zero manual review for standard cases.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.