Tools, agents and protocols: Claude Code, Codex, MCP and everything I use every day.
I close the terminal mid-refactor and the next day *Codex CLI* has forgotten everything? No: every conversation is a **session** saved to disk as a *JSONL* file, and with **codex resume** I reopen it exactly where I was. ==I never start from scratch==: I look at the interactive picker, the *--last* shortcut, resuming by name or ID, forking to experiment without breaking the original, and the *exec resume* variant for scripts.
An **output style** changes *how* Claude Code responds, not what it knows: it rewrites the *system prompt* and applies on every turn. I go through the four built-in styles — Default, Proactive, Explanatory, Learning — and how I write my own in a markdown file. Then the two things almost every guide out there is still stuck in 2025 on: ==the /output-style command is gone, you go through /config==, and without *keep-coding-instructions* a custom style switches off Claude's software engineering instructions.
If you have already connected some existing **MCP server** and now want to ==write your own==, this is the guide I wish I had found myself. I show you what an MCP server really is inside, how I bootstrap it in **Python with FastMCP**, how I expose the first *tool* and how I hook it to a real internal system — with a serious eye on **security** and what ==should NEVER== be exposed.
In the *--full-auto* piece I covered the sandbox; here I turn the other dial: the **approval policy**, meaning when Codex stops and asks my permission before acting. The three values — *untrusted*, *on-request*, *never* — sound self-explanatory but they are not: *untrusted* only auto-runs ==the reads known to be safe==, and *never* does not switch off the sandbox at all. I also cover the two options quick guides skip: the granular per-category policy and Auto-review, which routes approval requests to an automatic reviewer instead of me.
I open *Claude Code* in a project and have to re-explain the structure, commands and conventions every time? No: what I'd say out loud I write once in a **CLAUDE.md** file, which the assistant reads at the start of every session. ==It isn't configuration that enforces, it's context that guides==: I look at where the files live in the memory hierarchy, how I write instructions that actually get followed, how I import other files with *@path*, and how I generate and verify everything with */init*, */memory* and */context*.
**Record a Skill** is the new way to teach *Claude Cowork* a workflow in the desktop app: from the composer's **+** menu you hit record, do the task once while you narrate *what* you're doing and *why*, and Claude turns the demonstration into a reusable ==Skill== you can trigger later with a slash command. In this article I walk the whole flow end to end — where the button lives, what Claude builds the moment you stop, what you actually get (a plain SKILL.md), how you re-run it, and which workflows are worth recording and which ones aren't.
The *--full-auto* flag in Codex CLI is the shortcut everyone learns first: no approval prompts and writes confined to the repository. But there's more underneath: **--full-auto forces the sandbox to workspace-write** and even wins over a *--sandbox* flag passed next to it, and on *codex exec* it is now ==a deprecated compatibility path== that prints a warning. I look at what it really does, how the sandbox works across its three modes, and the pair of explicit flags I use in its place.
**OpenCode** is the open source coding agent that lives in your terminal and talks to ==75+ providers==: Claude, Codex, Copilot and even local Ollama. In this tutorial I install it, configure it with a multi-model opencode.json, and then go one step further: I turn it into an HTTP API and call it from a **.NET 9 Minimal API** with Refit. The .NET snippets are verified by an automated build and tests.
CLI agents are great at consuming tokens and terrible at stopping on their own. Both **Codex CLI** and **Claude Code** now ship real levers to cap consumption: ==/goal with a token budget== and *rollout_budget* in **config.toml** on one side, ==/usage, /compact and environment variables== on the other. In this article I collect the commands and configuration keys I actually use, plus a cheat sheet to keep within reach.
I close the terminal, come back the next day, and *Claude Code* has forgotten everything? No: every conversation is a **session** saved to disk, tied to the project directory. With **--continue** I pick up the last one instantly, with **--resume** I choose which to fish out of the *session picker*. ==I never start from scratch==: I look at the difference between the two commands, how I find an old conversation, how I branch a session with *--fork-session* and where the transcripts end up.
Every time I open *Codex CLI* in a new repo I end up repeating the same instructions: how the tests run, which conventions I follow, what not to touch. The **AGENTS.md file** solves exactly this: Codex reads it ==before it starts any work== and builds an instruction chain from the global file in *~/.codex* down to the project one. I look at what AGENTS.md really is, how its layered discovery works, the role of *AGENTS.override.md* and fallbacks, and the flow I follow to write a useful one.
An **orchestrator** puts a single interface in front of Claude Code and several backends behind it: ==Ollama locally for simple tasks, Claude and OpenAI/Codex in the cloud for the hard ones==. In this tutorial we install and configure the **Claude Code Router** step by step, from scratch.
Claude Code, GitHub Copilot, Cursor and Gemini aren't the same tool with a different name: each **wins on a specific terrain**. We use all four every day, and here we compare them on real criteria — context, agent mode, MCP, local work, privacy, cost — to say ==which one fits which scenario==, without fanboyism.
On June 2, 2026 Microsoft announced **Scout**, its first **Autopilot**: an ==always-on== AI agent that lives inside Microsoft 365 and *acts on its own* across calendar, mail, Teams and OneDrive. It is not another Copilot: it is a **different category**. Here is what it really changes for a small or mid-sized business — and the three questions to answer before turning it on.
Claude Code writes fast, but *who reviews*? An idea: a **plugin** that at session end hands the *diff* to a small team of AI reviewers — **Junie, Copilot, Gemini, Codex** — ==but only the ones actually installed on your PC==. If one is missing it is simply skipped: no errors.
When a *Claude Code* session runs long, the bottleneck isn't the model — it's the **context** filling up with searches, logs, and files I'll never re-read. **Subagents** exist for this: specialized assistants that work in their own context and return ==only the summary==. I look at what the **/agents** command does, how I create a subagent in a few steps, and the three fields (description, tools, model) that decide whether delegation actually works.
Adding an **MCP server** to Claude Code and to Codex follows the same shape: one command to manage them and one file where they are listed. Here you see the **/mcp** command, the *add*, *list* and *remove* subcommands, and the configuration files — *~/.claude.json* and *~/.codex/config.toml* — with the *Playwright* server explained ==line by line on annotated screenshots==.
VS Code ships **MCP** support built in: *MCP servers* add tools, resources and prompts to agentic chat. You install them two ways — from the *Extensions* view by searching **@mcp**, or by hand-writing the **.vscode/mcp.json** file. In this guide I set up the *Playwright* server, wire secrets and a sandbox, and show ==where to read the logs when something won't start==.
A **marketplace** is just a GitHub repo with one JSON file: from there *Claude Code* installs your plugins ==with a single command, on any machine==. In this tutorial I create a **private** repo, drop in a plugin that saves the session to **Obsidian** and expose it with two commands — */salva-session* and */salva-session:compact*. All installable **remotely**, not from a local folder.
**settings.json** is the real control panel for *Claude Code*: a handful of lines decide whether the agent works as a **team**, how it loads *MCP* tools, what it does ==at the end of every session== and where it installs plugins from. I start from my real file — ==with sensitive data redacted== — and break down the four sections I touch most, with links to the official docs.
On **18 June 2026** the *Model Context Protocol* published its *Enterprise-Managed Authorization*: AI agents like Claude can now connect to the CRM, email, and ERP **with a single SSO login**, centralised logs, and immediate revocation. For an SME, ==the last real barrier== to agent adoption disappears: no more dozens of disconnected OAuth flows, no more personal accounts glued to company systems. Here is what actually changes, what it means for businesses that have already tried Claude or ChatGPT, and the first concrete steps to get there.
The interactive mode of *Codex CLI* is great for exploration, but when I need to plug the agent into a *pipeline* I need something different: **codex exec** runs a single task ==without opening the interactive terminal== and exits. Progress on *stderr*, final result on *stdout*, JSON output for scripts, and a read-only sandbox by default. I look at what codex exec actually does, how to read its output from a script, and the flow I use to run it in CI with minimal permissions.
In long *Claude Code* sessions the real bottleneck isn't the model — it's the **context** filling up. The **/compact** command summarises the conversation and puts it back on track, but if I let auto-compaction decide when to fire it can kick in ==at the worst possible moment==. I look at what /compact actually does, how to guide it with a focus, and the workflow I follow to keep context below 60% and spend fewer tokens.
On 28 May 2026 Anthropic released **Claude Opus 4.8** alongside the research preview of *Dynamic Workflows*: ==hundreds of subagents running in parallel within a single session==, 1M-token context and **4× fewer code errors** slipping through undetected. Here is what this really changes for **enterprise vibe coding** in Italian SMEs and how to move forward without being overwhelmed by costs.
May 2026 brought, within days, Salesforce's *Agentforce Operations*, the new generation of IBM *watsonx Orchestrate* at Think 2026, and Camunda *ProcessOS* in beta. It signals that **agentic AI** has ==moved out of the demo phase and into real business processes==. What does this mean concretely for **companies** and where to start **without burning budget**.
COOL