Ideas, methods and real cases on AI applied to business

Practical articles written by someone who builds software every day: no hype, no empty theory. Only what we see working in real projects — vibe coding, AI integration in apps, agentic workflows, OCR, automation in business processes.

Vibe coding

Git worktrees with Claude Code: isolated parallel sessions with the --worktree flag

Two Claude Code sessions on the same checkout end up ==stepping on each other's files==. **Git worktrees** fix that at the root: each session works in a *separate directory* on its own branch, and with Claude Code's native support the **--worktree** flag is all it takes to start isolated. In this tutorial I cover the whole cycle: the flag and its defaults, **.worktreeinclude** to carry .env files along, the four checks Claude Code uses to ==enforce the isolation==, subagents with isolation: worktree, picking the base branch with baseRef, cleanup and resume — and how I replicate the pattern with **Codex**.

August 24, 202613 min read

.NET

LLM chat memory in ASP.NET Core: IChatReducer and MongoDB

HTTP APIs are stateless, LLM chats are not: every turn needs to see the story so far. Resending *everything* on each message blows up ==tokens and the context window==. In this tutorial I build a .NET 9 Minimal API where **MongoDB keeps the full transcript** and the model only receives the view reduced by a **IChatReducer** from *Microsoft.Extensions.AI*: the last N messages, or an LLM-generated summary. Fully local with Ollama, and measurable on every single reply.

August 18, 202615 min read

Vibe coding

Claude Code agent teams: one lead, parallel teammates and a shared task list on a .NET project

**Agent teams** are the experimental *Claude Code* feature that turns a session into a ==coordinated team==: one **lead** that plans and assigns, plus independent **teammates** that talk to each other and share a *task list*. In this tutorial I try them on a .NET Minimal API split into three modules: a parallel review on three fronts, reusable roles via subagent definitions, **plan approval** before any code, and a **TaskCompleted** hook that blocks tasks closed with red tests.

August 15, 202614 min read

AI & agents

Codex resume: picking CLI sessions back up without starting over

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.

August 14, 20268 min read

.NET

RAG vs Agentic RAG: when retrieval is no longer enough

**Classic RAG** retrieves once and answers with the chunks it found. **Agentic RAG** exposes three tools to the LLM — *search*, *evaluate*, *refine* — which the model can use to iterate within a configured limit. I built them ==side by side in .NET 9==: same dataset, same questions, two endpoints. With code, traces and an operational benchmark.

August 12, 202616 min read

.NET

LLM observability in .NET: traces, tokens and cost with OpenTelemetry and the Aspire dashboard

An endpoint that calls an LLM is **a black box**: you don't know how long it waited, how many tokens it burned, what it cost. In this tutorial I instrument a ==.NET 10 Minimal API== with *OpenTelemetry* and *Microsoft.Extensions.AI*: spans that follow the *GenAI semantic conventions*, token and latency metrics, a hand-written **cost counter**, all visible in the **Aspire dashboard** running in Docker next to *Ollama*.

August 9, 202621 min read

AI & agents

Claude Code output styles: change the system prompt without losing the coding agent

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.

August 7, 20268 min read

AI & agents

Build a custom MCP server from scratch (with code)

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.

August 7, 202612 min read

Vibe coding

Claude Code: the complete guide

**Claude Code** is a coding agent that lives in your *terminal*: it reads the project, edits files and runs commands on its own. This guide lays out everything you need to go from ==curious to productive== — install, the rules file, permissions, external tools, hooks, subagents and the token bill — and each chapter points to the deep-dive tutorial I already wrote.

August 6, 202616 min read

.NET

LLM evaluation in .NET: testing response quality with Microsoft.Extensions.AI.Evaluation

How **LLM evaluation** works in .NET: unit tests verify code, but ==a model's response is not deterministic== and must be *judged*, not compared. With *Microsoft.Extensions.AI.Evaluation* I build an ==xunit suite== that scores the *relevance*, *coherence* and *groundedness* of an assistant's answers, with a **local judge via Ollama**, disk-based caching and an ==HTML report== ready for CI.

August 6, 202618 min read

Vibe coding

TDD with Claude Code in .NET: red-green-refactor with a Stop hook and a guardian subagent

**TDD** is the perfect leash for a coding agent: the test written *first* defines the behaviour, and the agent writes ==only the code that makes it pass==. In this tutorial I build a **.NET Minimal API** with *Claude Code* in pure red-green-refactor, and I mount two guardrails: a **Stop hook** that re-runs dotnet test whenever the agent tries to call itself "done", and a **subagent** that checks the tests were not weakened.

August 3, 202615 min read

AI & agents

Codex CLI approval policy: untrusted, on-request, never and the granular policy

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.

July 31, 20268 min read

.NET

Hybrid search in .NET with Qdrant, BM25 and Ollama

==Hybrid search== in .NET: **dense** vectors and **BM25** keywords fused into *one ranking* with **Reciprocal Rank Fusion**. One Qdrant collection with *two named vectors*, local embeddings via *Ollama* and *Microsoft.Extensions.AI*, and a **Minimal API** that compares the three modes — *dense*, *keyword*, *hybrid* — over the same knowledge base. Then the level-up: a **RAG** endpoint that sends the retrieved documents to a local LLM, a **semantic cache** of the answers on Qdrant, **Redis** for output caching and **MongoDB** with a generic repository and pagination. Bonus: the AI provider becomes an *appsettings* switch — Ollama or any **OpenAI-compatible** endpoint — plus a hard look at **Microsoft Agent Framework**.

July 31, 202638 min read

Vibe coding

Claude Code in GitHub Actions: automated PR review with claude-code-action

The review loop I run locally with *Claude Code* — diff, critique, fix — can run on its own in CI. With **claude-code-action**, every pull request allowed by the trigger and fork policy gets an ==automatic review==, while an authorized collaborator can use an @claude mention to request an answer or a code change. I start in **non-interactive mode** (claude -p), move the prompt into GitHub Actions, and set separate guardrails for ==tools, turns, budget and permissions==.

July 30, 202611 min read

.NET

Semantic caching for LLMs in .NET with Redis and Ollama

==Semantic caching== for **LLMs** in .NET: a *two-layer* cache that answers **repeated** and *reworded* questions without re-running the model. Exact match with *UseDistributedCache*, a *semantic* layer with embeddings and vector search on **Redis 8**, in a **Minimal API** with *Microsoft.Extensions.AI* and *Ollama*.

July 27, 202627 min read

AI & agents

CLAUDE.md: give Claude Code a persistent project memory

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*.

July 24, 20268 min read

Vibe coding

Keep Claude Code out of sensitive files: a PreToolUse hook for .env, keys and secrets

A **PreToolUse hook** in *Claude Code* is the simplest, most reliable barrier to stop the agent from opening, reading or editing sensitive files — .env, keys, credentials, private folders. I walk through the setup I use: a tiny script that reads the JSON on stdin, checks the path of a Read/Edit/Write call and ==exits with code 2== to block the tool before it runs, returning a message Claude reads and understands. A few lines of bash, one entry in settings.json, and your repo is ==shielded== from even the most eager agent.

July 24, 20269 min read

AI & agents

Record a Skill: teach Claude Cowork a workflow by recording your screen

**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.

July 24, 202610 min read

Vibe coding

Custom skills for Claude Code: creating, testing and distributing them

A **skill** is a folder with a SKILL.md file: instructions *Claude Code* loads only when needed, not on every turn like CLAUDE.md. In this guide I build a real one — changelog-entry, which drafts a changelog section from the commits since the last tag — covering ==dynamic context==, arguments, pre-approved tools, supporting files and testing with skill-creator, down to choosing between a personal, project, or plugin skill.

July 21, 202613 min read

.NET

LLM streaming in ASP.NET Core: token-by-token responses with SSE and Microsoft.Extensions.AI

LLM responses that arrive **token by token**, just like ChatGPT: in this tutorial I build a ==.NET 10 Minimal API== that streams from a local model with *Ollama* and *Microsoft.Extensions.AI*, and exposes it to the browser with ASP.NET Core's native **Server-Sent Events** — TypedResults.ServerSentEvents, zero extra libraries.

July 18, 202618 min read

AI & agents

Codex CLI --full-auto: what it really does, why it's deprecated, and what I use instead

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.

July 17, 20268 min read

AI & agents

OpenCode: the complete tutorial, from install to a .NET Minimal API gateway

**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.

July 17, 202627 min read

.NET

Structured output in .NET: typed JSON from an LLM with Microsoft.Extensions.AI

Structured output with *Microsoft.Extensions.AI*: why asking for JSON "please" in the prompt isn't enough, how a record C# becomes a *JSON Schema* that constrains the model, and a ==tutorial Minimal API .NET== where a local LLM with *Ollama* triages help desk tickets returning ==typed objects==, then saved to *MongoDB*.

July 15, 202619 min read

AI & agents

Token limits in Codex CLI and Claude Code: /goal, budgets and commands

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.

July 14, 20267 min read

.NET

Function calling in .NET: let an LLM call your own code with Microsoft.Extensions.AI

**Function calling** with *Microsoft.Extensions.AI*: what it is, when to use it (and how it differs from *RAG*), and a ==.NET Minimal API tutorial== where a local LLM running on *Ollama* calls your own C# methods — reading orders from *MongoDB* and prices from an external API with *Refit*.

July 13, 202621 min read

AI & agents

Claude Code --resume and --continue: pick up sessions without starting over

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.

July 10, 20268 min read

Vibe coding

Claude Code hooks: deterministic quality gates for lint, tests and safety

**Hooks** turn *Claude Code* from a persuadable assistant into a system with guarantees: they are shell commands that fire at precise points of the lifecycle and can ==block an action or fix it automatically==. In this guide I build four real *quality gates* — format and lint on PostToolUse, blocking dangerous commands on PreToolUse, mandatory green tests on Stop, project context on SessionStart — covering events, matchers, exit codes and JSON output.

July 9, 202612 min read

.NET

AI Agent Orchestration: patterns, frameworks and an ASP.NET Core example

==AI agent orchestration== is the pattern that in 2026 is replacing the single agent for complex tasks. Here I walk through the **4 patterns** (hierarchical, collaborative, competitive, hybrid), the **frameworks** that matter — from *LangGraph* and *CrewAI* to the *Microsoft Agent Framework* — and a **hands-on ASP.NET Core example** that orchestrates four specialised agents in a few lines.

July 8, 202613 min read

.NET

MCP transport protocols: stdio, HTTP and authentication in C# .NET

==MCP transport protocols== explained in depth: **stdio** for local servers and **Streamable HTTP** for remote ones, with a note on the deprecated *HTTP+SSE*. When to pick *one over the other*, how **authentication** works (OAuth 2.1), and two **C# .NET** examples with *Microsoft Agent Framework* and *Microsoft.Extensions.AI*: one stdio without auth (Filesystem) and one HTTP with auth (GitHub).

July 7, 202624 min read

AI & agents

Codex CLI and AGENTS.md: persistent instructions for the agent, from global to project

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.

July 5, 20268 min read

.NET

RAG from scratch in .NET: types, databases and a tutorial with Ollama and MongoDB

**RAG** explained from scratch: what it is, the *types* (hybrid, graph, re-ranking, agentic), which **vector databases** to choose — with Docker or cloud — and a ==Minimal API .NET tutorial== using *Ollama* for the LLM and embeddings and *MongoDB Community 8.2* for vectors and hybrid search.

June 30, 202626 min read

AI & agents

Claude Code Router: a step-by-step tutorial to orchestrate Ollama, Claude and Codex

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.

June 29, 202614 min read

AI & agents

Claude Code vs Copilot vs Cursor vs Gemini: which AI coding assistant to choose in 2026

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.

June 29, 202613 min read

AI & agents

Microsoft Scout: what changes for SMBs with an always-on AI agent

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.

June 26, 20268 min read

AI & agents

A plugin that has other AIs review Claude Code

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.

June 26, 20268 min read

AI & agents

Claude Code /agents: creating specialized subagents to delegate tasks without flooding your context

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.

June 26, 20267 min read

AI & agents

Add an MCP server to Claude Code and Codex

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==.

June 25, 20269 min read

AI & agents

MCP servers in VS Code: install and configuration

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==.

June 24, 20269 min read

AI & agents

Build your own Claude Code plugin marketplace on GitHub

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.

June 23, 202611 min read

AI & agents

Claude Code settings.json: configure agent teams, hooks and marketplaces

**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.

June 23, 20268 min read

AI & agents

MCP Enterprise Authorization: the missing piece for bringing AI agents into Italian SMEs

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.

June 19, 20268 min read

AI & agents

Codex CLI codex exec: automating Codex in CI and scripts

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.

June 19, 20267 min read

AI & agents

Claude Code /compact: how to manage context and cut costs in long sessions

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.

June 15, 20266 min read

Tips

Claude plugins and connectors for SMEs: contracts, email and Excel without an IT project

Most repetitive work in an SME does not live in the ERP: it lives **in contracts to review, in the email inbox and in Excel spreadsheets**. In 2026 Anthropic released plugins and connectors that bring Claude exactly there — ==without writing a single line of code==. I look at what the Legal plugin, the email connector and Claude for Excel actually do, and where the right place to start is.

June 12, 20269 min read

Tips

Shadow AI in SMEs: how to govern AI agents without killing productivity

In 2026 ==68% of employees use AI tools without IT authorisation==, and Gartner estimates that **40% of enterprise applications will have integrated AI agents by year-end**. For a small or mid-sized business the risk is not theoretical: it's the consultant pasting a contract into ChatGPT, the sales rep leaving an agent with access to the company inbox. I look at what *shadow AI* means in practice and how to set up lightweight governance — five pillars, a one-page policy, zero IT project.

June 12, 20269 min read

Vibe coding

From vibe coding to agentic engineering: what changes for Italian SMEs from 1 June 2026

On 1 June 2026 **GitHub Copilot's consumption-based billing** came into effect and Andrej Karpathy officially declared *vibe coding* a closed chapter, replaced by **agentic engineering**. ==For Italian SMEs this is not a semantic nuance==: the cost model changes, governance changes, and who can actually bring AI into production changes. Here is what to do in the next 8 weeks.

June 5, 20268 min read

AI & agents

Claude Opus 4.8 and Dynamic Workflows: what changes for enterprise vibe coding in Italian SMEs

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 29, 20268 min read

AI & agents

Agentic AI in Business Processes: What Changes for Companies After the May 2026 Announcements

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**.

May 25, 20268 min read

Vibe coding

Vibe coding: what it is and how to bring AI into development

**Vibe coding** is the practice of delegating part of the code-writing to a *conversational AI assistant*, keeping the ==developer in the driving seat==. It is not hype: it is a **process change** that requires tools, policies, and metrics. Here is how to introduce it seriously.

May 10, 20269 min read

Tips

Business OCR with AI: Benefits, Implementations, and a Real Use Case

**Modern OCR** is no longer just "reading text from an image": it is a *document AI layer* that ==extracts structured data from invoices, contracts, and identity documents== and writes it directly into your systems. Discover concrete benefits, implementation scenarios, and a **real use case**.

May 8, 20268 min read

Tips

AI automation for non-IT departments: HR, marketing, administration and operations

**AI automation** is no longer a topic reserved for the IT department. ==HR, marketing, administration and operations== are today the primary consumers of AI solutions in business — and the first to benefit from a **measurable ROI**. Here is where to start, how to structure the project and which mistakes to avoid.

May 5, 202610 min read

Tips

Custom CRM: when it beats Salesforce, HubSpot and off-the-shelf platforms

Salesforce, HubSpot, Pipedrive cover ==70% of standard use cases==. For the remaining 30% — companies with *atypical sales processes, proprietary integrations, or strict privacy requirements* — a well-designed **custom CRM** is often **faster, cheaper in the medium term, and more functional** than a generic platform forced into a role it was never built for.

May 2, 20269 min read

Frontend

Business website and landing page in 2026: SEO, conversion, and brand identity

A modern business website must do **three things at once**: get found (SEO), convert visitors into leads (CRO), and tell the brand story well. The technologies of 2026 — high-performance static sites, AI for content, schema markup — make everything easier, but ==the method matters more than the technology==.

April 28, 20268 min read

Ideas, methods and real cases on AI applied to business

Cool Solution Newsletter