// Topic

AI Workflows & Automation

How to wire AI agents and coding assistants into real work: choosing models, setting up coding agents, connecting tools with MCP, and automating the busywork without losing control.

The promise of AI at work is not a smarter chatbot. It is the boring stuff done for you, a refactor that spans forty files, a release note drafted from the diff, a research pass that reads twenty sources while you do something else.

Getting there takes more than a good prompt. You need the right model for the job, an agent setup that holds context across a long task, tools wired in so the agent can act, and guardrails so it fails safely. The posts below are the practitioner's path into that setup.

The work-faster thread is the newest on the site and it is still growing. Follow it for the workflows I run myself, and the playbooks I am writing next.

Choosing your tools

Pick the model and the agent that fit the job before you automate anything.

The Best LLMs for Coding in 2026: An Engineering Review

Not all models are created equal for software development. Here is a benchmark-backed guide to choosing the right LLM for autonomous agents, algorithmic logic, and repository-scale refactoring as of March 2026.

7 min read ai llm technical-writing

Beyond the Chatbox: Benchmarking Claude Code vs. Gemini CLI for Autonomous Repository Refactoring

I ran a head-to-head benchmark of Claude Code and Gemini CLI on an M2 Air (16GB), testing their ability to autonomously refactor legacy code and resolve race conditions.

7 min read agentic-cli benchmarking developer-productivity

Setting up coding agents

Make a coding agent hold context across a long task instead of forgetting halfway.

How I Set Up a Coding Agent That Actually Finishes the Task

A coding agent succeeds or fails before it writes a line. Here is the setup I use, the rules file, repository context, tools, permissions, and guardrails, that turns a capable model into an agent I trust with real work.

9 min read ai agents devtools

How Memory Works in Claude Code

A practical guide to understanding how Claude Code retains context across sessions, uses project files, and manages long-term memory for coding tasks.

17 min read ai claude agents

Why Your Coding Agent Keeps Forgetting Everything: Memory Persistence in AI Coding Assistants

The memory persistence patterns that actually work for AI coding assistants, and why most agents lose context between sessions.

9 min read ai-agents coding memory

Agent Harnesses: the Infrastructure Layer Your Llm Agent Actually Needs

Every production AI agent needs a harness. Here is what one contains, why frameworks often are not enough, and how to build the layer that actually determines reliability.

10 min read ai agents infrastructure

Wiring tools and context

Connect the agent to your real tools and data so it can act reliably.

Wiring Tools into Your Agent with MCP: A Practical Setup

A hands-on guide to connecting an AI agent to your own tools and data with the Model Context Protocol. The client-server shape, a minimal working server, tool design, and the guardrails that keep it safe.

9 min read ai agents developer-experience

The Model Context Protocol (MCP) Explained: A Universal Language for AI Tools

Model Context Protocol (MCP) is the new standard for connecting AI models to data sources and tools. Here is why it matters, how it works, and why it is the missing link for agentic infrastructure.

8 min read ai agents infrastructure

Structured Outputs with LLMs: JSON Mode, Function Calling, and When to Use Each

JSON mode, function calling, and structured outputs solve different problems. Here's when each one actually makes sense and what they cost you.

12 min read ai llm infrastructure

Designing the workflow

Decide what the agent owns, what stays manual, and how many agents you need.

The Agentic Workflow Playbook: From Prompt to Shipped PR

The repeatable five-stage process I run to take a task from vague intent to a pull request I trust, with an AI agent doing the heavy lifting and me stepping in to frame the work and read the diff before it merges.

9 min read ai agents developer-experience

When to Build an Agent and When to Build a Smarter Assistant

The difference between an AI agent and a smart assistant comes down to one thing: who drives the loop.

6 min read ai agents ai architecture agent design

The Agent Design Space: A Map of What Engineers Are Actually Building

After surveying production agents across industries, the design space clusters into patterns. Here is what I found.

8 min read ai agents architecture

Multi-Agent vs Single-Agent Systems: The Real Trade-offs

The decision between one agent and many is not about capability. It is about failure modes, latency, and operational complexity.

6 min read ai agents multi-agent systems agent architecture

Automating developer busywork

Concrete wins: faster tooling and content drafted from your own artifacts.

From 4 Minutes to 12 Seconds: A Quantitative Audit of the uv Package Manager

I benchmarked Astral uv against Poetry and pip on a 2026 AI dependency stack. Here is how Rust-native tooling reduces build times by 20x.

8 min read python devtools benchmarking

How to Write a Changelog That Developers Actually Read

Most changelogs exist to satisfy a checkbox. Here's what makes developers actually read them, and how to structure entries so breaking changes land before they cause incidents.

11 min read technical-writing developer-experience devtools

Writing Release Notes That Developers Trust

Developers trust release notes when they can make upgrade decisions fast. I explain the format, level of detail, and disclosure standard that earns that trust.

11 min read technical-writing developer-experience releases

Frequently asked questions

What is an AI workflow?

An AI workflow is a repeatable process where one or more AI agents do part of the work, wired into your real tools and data. It is the difference between asking a chatbot a question and handing an agent a task it completes end to end.

Which LLM should I use for coding agents?

It depends on the job. Use a fast cheap model for autocomplete and small edits, and a stronger model for architecture and repository-scale refactors. The best-LLMs-for-coding post gives a benchmark-backed breakdown.

How do I connect an AI agent to my tools?

The cleanest path today is the Model Context Protocol, which exposes tools and data through a common interface an agent can call. The MCP post explains how it works and why it beats one-off integrations.

Can I trust an agent to automate real work?

Only with guardrails. Give the agent clear tool schemas, scoped permissions, error handling, and a way to observe what it did. The agent-architecture posts cover how to make automation fail safely.

Need a technical writer who gets this?

I write for DevTools and B2B SaaS companies. Let's talk.