Building Production-Ready AI Agents: Proper Use of Skills, MCP, and CLI

From early demos in 2024 to coding agents in 2025 and finally deploying general‑knowledge agents in 2026, the article outlines a three‑layer connectivity stack—Skills, CLI/Computer Use, and MCP—that must be used together for production‑level AI agents.

Understanding the Three‑Layer Stack

Skills (Domain Knowledge)

Skills are reusable, procedural instructions stored as Markdown files under .claude/skills/. They teach the model how to use tools across clients. The article references two public skill repositories: superpowers and everything-claude-code (see references [1] and [2]).

CLI / Computer Use (Local Execution)

The CLI follows a class‑Unix style, offering high token efficiency (≈200 tokens per response) by leveraging pre‑trained knowledge of tools such as git, gh, and curl. Installation is performed via standard package managers.

MCP (Connectivity Technology)

MCP provides a rich, platform‑agnostic integration layer with OAuth, governance policies, and audit trails. Tools, resources, and prompts are defined in code (e.g., server.py or server.ts) and communicated via JSON‑RPC 2.0 over HTTP or SSE.

When to Use MCP

MCP is ideal for scenarios requiring rich semantics, authorization, and platform independence. It offers schema‑first deterministic tool selection, but naïve implementations load all tool schemas into the context, incurring significant token overhead.

Always use descriptive function and parameter names with comments; LLMs call tools faster and more accurately when expectations are explicit.

from typing import Annotated
from datetime import date
from enum import Enum

class Category(str, Enum):
    TRAVEL = "travel"
    MEALS = "meals"
    OFFICE = "office"

def submit_expense(
    amount: Annotated[float, "The expense amount in USD"],
    date: Annotated[date, "Date of the expense in YYYY‑MM‑DD format"],
    category: Annotated[Category, "The expense category"]
) -> str:
    """Submits a new expense report for approval."""
    pass

Core Optimizations: Progressive Discovery

Instead of loading every tool at once, agents should lazily load tools only when needed. Providing a tool_search capability can reduce context usage by up to five‑fold.

Spring AI experiments with 28 tools showed a 34‑64% token reduction for OpenAI, Anthropic, and Gemini models. An A/B test by Cursor reported a 46.9% decrease in total token consumption when using MCP‑enabled sessions.

Advanced Optimization: Programmatic Tool Calls (Code Mode)

For multi‑tool orchestration, avoid sequential tool calls that add inference latency. Instead, enable Code Mode, giving the model a REPL environment (e.g., V8 isolate or Python sandbox) to write a script that composes tools.

// Programmatic tool calls (Code Mode)
// The model writes a script once instead of many LLM rounds:
const issue = await mcp.call_tool('linear_get_issue', { id: 'ENG-5121' })
const prs = await mcp.call_tool('github_list_prs', { repo: 'frontend' })

// Enforce typed output
const expectedType = z.object({
    title: z.string(),
    status: z.string(),
}).passthrough()
const typedIssue = await extract('claude‑haiku‑4‑5', expectedType, issue)

Designing for Agents, Not Humans

Server authors should stop mapping REST APIs one‑to‑one onto MCP servers. Instead, design tools from the agent’s perspective, embrace Code Mode, and deliver MCP apps that expose rich semantics (HTML + JS + CSS) for client‑side rendering.

Design tools for agents – clear intent, similar to UI design for humans.

Embrace Code Mode – expose execution environments (e.g., Cloudflare MCP) for complex workflows.

Deliver MCP apps – use MCP’s semantics to ship UI resources directly.

MCP 2026 Roadmap

The ecosystem is evolving to meet enterprise needs. Core improvements include a stateless transport protocol for easier deployment on Kubernetes and Cloud Run, and upcoming TypeScript and Python SDK v2.0.

Ubiquitous integration will add SSO via corporate identity providers, with server discovery via .well-known/mcp-server-card/server.json. Boundary expansion will let Skills be served over MCP through skills/list and skills/get endpoints, bundling domain knowledge with tools.

Conclusion

2026 demonstrates that there is no silver bullet for agent connectivity. The MCP vs. CLI debate is a false dichotomy; production agents need a multi‑layered, fine‑grained approach. While MCP faces challenges—token cost, authentication gaps, server quality—these are engineering problems that progressive discovery and Code Mode already mitigate. Abandoning MCP introduces worse issues such as fragmented authentication, lack of audit trails, and vendor lock‑in. The future of enterprise agents lies in seamlessly combining Skills’ domain expertise, MCP’s secure connectivity, and CLI’s token‑efficient execution.

References

[1] superpowers: https://github.com/obra/superpowers

[2] everything-claude-code: https://github.com/affaan-m/everything-claude-code