🤖 Building with Agents

Harnesses, agent workflows, orchestration, loop engineering.

BlogAnkit Desai

The Carbon Layer: Building a Coding Agent From Scratch

A 15-chapter educational build of a working coding agent in ~2,500 lines of Python, running a local model, with each chapter adding one architectural primitive rather than hiding it behind a framework.

Frames an agent as Model + Harness + UI, with strict one-way imports (UI → harness → model) so the harness stays swappable and framework-free.
The model is stateless; the harness fakes memory by replaying the full message history, and enforces safety at the boundary — the model decides what to call, the harness decides how and actually runs it.
Treats task completion like a pre-commit hook the model can't skip: it demands an observed zero-exit-code command run in the transcript, not a claim.

View ↗

added by Radar • 28th Aug 2026

PaperAbhilasha Lodha, Mahsa Pahlavikhah Varnosfaderani, Abir Chakraborty, Abhinav Mithal

Less Context, Better Agents: Full Chat History Hurts Long-Horizon Agents

A paper showing that pruning an agent's context to recent tool calls plus a running summary beats keeping full chat history, on a 50-task tool-using benchmark.

Full chat history scored worst at 71% task completion; pruning to the last 5 tool call/response pairs raised it to 79% while cutting tokens from 1.48M to 535K.
Adding automated summarization on top of pruning performed best of all, and also roughly halved benchmark runtime (14.56h → 5.79h).
The result argues for actively trimming agent context rather than hoarding it, especially on long-horizon, tool-heavy tasks.

View ↗

added by Radar • 17th Aug 2026

ToolSpotify

Xirp: Spotify's Vendor-Neutral Agentic Development Environment

Spotify's own agentic development environment for running and managing coding-agent sessions — across Claude Code, Gemini CLI, and Codex — in one place, now available outside the company.

Grounds agent sessions in real system context — service ownership, dependencies, architectural decisions — instead of starting from a blank slate.
Auto-generates living documentation from coding sessions that feeds back into future agent work; supports both local and remote execution.
Already in use by 1,300+ Spotify engineers internally before being opened up externally.

View ↗

added by Seb Kay • 10th Aug 2026

BlogMatt Rothenberg

You Don't Have a Design System

An experiment-backed essay arguing that a component library and token set aren't a design system if they don't also carry forward shared decisions about how the product should behave.

Three AI agents given the identical library (shadcn/ui on Base UI), token layer, and app shell each built a different settings page — some behind tabs, some as cards, some as long forms — despite passing the same token linter.
The failure wasn't in the components; it was in composition — nobody had made a canonical decision about what a settings page *is*, so each agent answered the question separately.
The real missing work of a design system is choosing an answer, making it canonical, and putting it where the next builder (human or agent) will find it.

View ↗

added by Adam Tomat • 5th Aug 2026

ToolFission AI

OpenSpec: Spec-Driven Planning for Coding Agents

A lightweight, spec-driven framework that has a coding agent draft a proposal, design decisions, and tasks before writing any code, then keeps that spec as living documentation in the repo.

Specs live in the repo alongside code — persistent context that survives across chat sessions and onboards new team members, instead of dying with the conversation.
Generates proposal docs, design decisions, tasks, and spec deltas up front, aiming for faster review cycles than reviewing generated code line by line.
Works across 30+ coding agents (Claude, Cursor, Copilot, Gemini CLI, and others) with no API key or custom protocol required.

View ↗

added by Neil Sweeney • 25th Jul 2026

BlogNoumena • xjdr

AI, Rockets, and the Return of Hard Contracts

An essay arguing that once AI makes code generation cheap, human line-by-line review becomes the bottleneck — so quality has to be enforced mechanically, through strict types and schemas, instead.

Proposes "disposable implementation, durable contracts": generated code is cheap and replaceable, but the types, schemas, and interfaces around it must be strict enough to catch errors before a human ever looks.
Uses the Apollo-vs-Soviet rocket engine design contrast — exhaustive preflight analysis vs. rapid build-fire-inspect-modify iteration — to argue the best approach combines both: fast generation, severe mechanical selection.
Calls for reversing the last two decades' drift toward loosely-specified, ergonomic systems — explicit contracts and state machines are what let generation scale from hundreds to thousands of implementations.

View ↗

added by Adam Tomat • 24th Jul 2026

BlogMatt Pocock

Tracer bullets: a fix for AI's bloated first drafts

A case for using "tracer bullets" — small, end-to-end vertical slices, a technique from The Pragmatic Programmer — to stop AI coding agents from producing bloated, half-finished features.

Left unguided, an agent tends to build out whole horizontal layers — endpoints, middleware, auth — before anything is tested, producing huge reviews and rework.
The fix is prompting the agent to ship one thin, working slice end to end, test it, gather feedback, then expand — rather than building in the dark.
Demonstrated by deliberately narrowing an agent's scope to a single backend endpoint wired to one UI location before letting it fan out further.

View ↗

added by Tom Harper • 23rd Jul 2026

ToolAaron Francis

Solo: A Lightweight Terminal Workspace for Running AI Agents

A lightweight, Tauri-based desktop app (not an IDE) for running CLI coding agents like Claude Code, Codex, and Gemini CLI alongside your dev server, databases, and terminals in one window.

Exposes MCP tools so agents can read process logs and state, auto-restarts crashed processes, and offers shared task lists, scratchpads, and locks for agent coordination.
Available on Mac and Windows (Linux coming soon); free tier covers up to 4 projects and 20 processes, Pro is $99/year for unlimited.

View ↗

added by Adam Tomat • 22nd Jul 2026

RepoPleasePrompto

google-ai-mode-skill: One-Shot Web Research for Claude Code

An open-source (MIT) Claude Code skill that offloads web research to Google's AI Mode, returning one cited, synthesized answer instead of having Claude read 5–10 pages itself.

Drives a real Chrome browser via Patchright with a persistent profile, so repeated CAPTCHAs don't pile up; supports DE/EN/NL/ES/FR/IT.
Extracts inline citations with 17+ fallback selectors and a 4-stage completion check, returning clean Markdown.
Zero-config Python install; only works with local Claude Code — the web UI's sandboxed environment has no network access to run it.

View ↗

added by Radar • 19th Jul 2026

BlogMoonshot AI

Kimi K3: Moonshot ships a 2.8T open MoE for long-horizon coding

Moonshot AI's release announcement for Kimi K3, a 2.8-trillion-parameter open Mixture-of-Experts model with native vision and a 1M-token context, aimed at long-horizon coding, knowledge work, and agentic tasks.

Uses Kimi Delta Attention and Attention Residuals with a Stable LatentMoE routing 16 of 896 experts — billed as "the world's first open 3T-class model."
Strong on kernel optimization, GPU compiler work, and complex software engineering; leads other open models on DeepSWE and Terminal-Bench, though still trails Claude Fable 5 and GPT-5.6 Sol.
Available now via Kimi.com, the Kimi Work app, Kimi Code CLI, and the API; full weights land 27 July 2026.

View ↗

added by Radar • 17th Jul 2026

BlogPrateek Solanki

Artifacts Without Inhabitants

An essay (published in two versions, one human-directed and one AI-generated) arguing that AI code generation is outrunning developers' ability to actually understand what's been built.

Unlike a compiler translating logic you've already worked out, AI "expands" a vague prompt into thousands of undirected decisions — a genuinely different kind of abstraction, not just a faster one.
Skipping the struggle of building erodes the "sensemaking history" that normally makes a system comprehensible, leaving working code that nobody really inhabits.
Cites research showing people's trust in AI tools rises even as their own sense of professional competence and authorship falls.

View ↗

added by Adam Tomat • 15th Jul 2026

BlogAlberto Arena

CLAUDE.md Is RAM, Not Disk

An argument for treating `CLAUDE.md` as small, constantly-loaded working memory, and pushing everything else into a `docs/` folder that's only pulled in on demand.

`CLAUDE.md` loads into every session and costs tokens every time, so keep it to a short project overview, pinned stack/versions, exact commands, and one-line pointers — not exhaustive detail.
Move deeper material into `docs/` (architecture in `DESIGN.md`, a phased roadmap in `PLAN.md`, a lightweight decision log in `DECISIONS.md`) referenced only when needed.
Nested, folder-level `CLAUDE.md` files keep domain-specific rules local instead of bloating the root file.

View ↗

added by Tom Harper • 15th Jul 2026

BlogBleepingComputer • Ax Sharma

GhostCommit: Prompt Injection Hidden Inside Images to Steal Secrets

A writeup of the "GhostCommit" attack, which hides malicious prompt-injection instructions inside PNG images referenced by config files, so a coding agent that reads the image later leaks repo secrets while text-based reviewers never open the binary.

A developer's later routine request makes the agent follow the hidden image instructions, pull secrets from `.env` files, and encode them as innocuous-looking integer lists that slip past secret scanners.
Which coding platform (e.g. Cursor, Antigravity) is running mattered more to whether the attack succeeded than the underlying model — Claude Code refused the attack across every model tested.
A concrete reminder that any binary asset pulled into a project (stock images, placeholders, loading spinners) is a plausible injection vector agents can act on without a human ever "reading" it.

View ↗

added by Adam Tomat • 14th Jul 2026

BlogUX Collective • Pablo Stanley

The Terminal Became My Canvas

A designer's account of shifting their primary creative tool from Figma/Illustrator to the terminal, working directly with AI coding agents to build products instead of mockups.

Reports building in a day what used to take weeks, crediting the shift from visual tools to text-based, agent-driven work.
Working in the terminal lets them explore many ideas in parallel instead of committing to one direction early, changing how fast concepts get validated.
Frames it as a genuine productivity paradox: real gains in speed and output, alongside real drawbacks from leaving familiar visual design tools behind.

View ↗

added by Adam Tomat • 14th Jul 2026

RepoJeffrey Emanuel

Destructive Command Guard: a Hook That Blocks Agents from Nuking Your Files

A Rust-based pre-execution hook ("dcg") that intercepts and blocks catastrophic commands (`git reset --hard`, `rm -rf ./src`, `DROP TABLE users`, etc.) before AI coding agents can run them, across Claude Code, Codex CLI, Gemini CLI, Copilot, Cursor and others.

Runs as a `PreToolUse` hook, parsing and pattern-matching each command through 50+ modular security packs (git, filesystem, databases, Docker, Kubernetes, cloud providers) with sub-millisecond, SIMD-accelerated filtering.
Distinguishes context to avoid false positives — it won't block `grep "rm -rf"` but will block an actual `rm -rf /`, and it scans heredocs/inline scripts (e.g. `python -c "os.remove(...)"`) that would otherwise slip through.
Started as a Python script from Jeffrey Emanuel, since rewritten in Rust with community contributions, and includes a pre-commit hook mode to catch dangerous commands during code review.

View ↗

added by Adam Tomat • 11th Jul 2026

Repoianhxu

A Sourced Field Study of How Agentic Engineering Actually Works

An open research study, produced by a multi-agent system, that surveys the emerging discipline of building software with AI coding agents, with eight sourced sub-reports plus a synthesis.

Covers context engineering, harness engineering, spec-driven development, loop engineering/multi-agent orchestration, practitioner workflows, and the tools/ecosystem landscape.
Lands on "Agent = Model + Harness" as the consensus framework — harness design (tools, context strategy, verification) sets the performance ceiling more than model choice alone.
Sketches a stable 15–20 hour learning path centred on context curation, editable planning artifacts, verification loops, and fresh-context review.

View ↗

added by Radar • 7th Jul 2026

PaperDongxin Guo, Jikun Wu, Siu Ming Yiu

The Deterministic Horizon: When Extended Reasoning Fails and Tool Delegation Becomes Necessary

A paper identifying a "deterministic horizon" of 19–31 reasoning steps, past which models should delegate state-tracking to tools rather than keep reasoning internally.

Tool-integrated approaches hit 86–94% accuracy versus 24–42% for pure chain-of-thought past that horizon.
Fine-tuning on optimal reasoning traces only closed the gap by <5%, pointing to an architectural ceiling rather than a training problem.
An "Attention Bottleneck Theorem" bounds state-tracking capacity; the effect held across 12 models and 8 task domains (r = 0.81–0.91).

View ↗

added by Radar • 6th Jul 2026

Repodanielalbinsson

An AI Agent That Reviews Pages for A11y and Design-System Drift

An open-source multi-agent tool that audits a live, rendered URL for accessibility, UX heuristics, and design-token drift, then produces a severity-ranked report — including as GitHub PR comments.

An orchestrator runs three specialist subagents in parallel: an accessibility auditor (axe-core), a visual-heuristics critic (vision models), and a design-system checker validating against design tokens.
Audits the actual rendered page in a real, headless-Chrome browser rather than reading source code.
Can be pointed at a pull request and post its findings directly as PR comments.

View ↗

added by Radar • 4th Jul 2026

BlogPaul Kinlan

How Might a Modern Lighthouse Work With LLMs?

A proposal for a Lighthouse-style auditing tool where checks are plain-language descriptions of good practice that an LLM judges from screenshots and traces, instead of hand-coded rules.

Combines a spec of good practices, machine-readable fix guidance, and evidence primitives (screenshots, heap snapshots, perf traces) as the model's "senses."
Runs a continuous find-fix-test loop rather than a one-shot audit, and reports fixing several real site issues this way (still with human review).
Because tests are descriptions of outcomes rather than code, anyone who can describe "good" can author a check — widening coverage into fuzzier, subjective quality dimensions.

View ↗

added by Adam Tomat • 4th Jul 2026

BlogDavid Wells

Multi-Agent Coding Without Worktree Chaos

A write-up of running multiple coding agents on one branch, coordinated by file reservations and messaging instead of separate git worktrees.

Swaps worktree-per-agent isolation for a shared branch plus explicit file reservations to stop silent collisions.
Models the work as a task graph with a "ring leader" agent assigning unblocked tasks to idle agents, rather than a flat checklist.
Agents send each other "mail" to flag API changes or blockers, so interdependencies stay visible across the swarm.

View ↗

added by Adam Tomat • 4th Jul 2026

RepoLaravel Boost

Laravel Boost Adds Committed Project Rules via an MCP Tool

A merged Laravel Boost PR that adds a `record-rule` MCP tool so agents can commit project-specific rules to versioned markdown files instead of relying on session memory.

Rules are stored as markdown with YAML frontmatter (a `paths:` field) in `.ai/rules/`, committed and reviewed like any other code change.
No separate search tool — agents just grep the repo for existing rules.
Ships behind a `BOOSTRULESENABLED` flag so teams can turn it off entirely.

View ↗

added by Tom Harper • 3rd Jul 2026

BlogChristine Vallaure

What Are Hypertokens? The Layer Between Tokens and Components, Rebuilt for Agents

Explores hypertokens, a proposed design-token layer (an exploration by Jake Albaugh's team at Figma) that bundles related style properties into one named source of truth compiled into every tool's format.

Solves token drift: bundles like typography (family, size, weight, line-height) currently live separately in CSS, Figma, and iOS, and go out of sync.
Gives agents a single semantic handle (e.g. `Surface.brand`) instead of fifteen loose values to guess how to connect.
Not yet shipped — still an exploration, but worth adopting semantic design-system practices now to align with it later.

View ↗

added by Adam Tomat • 3rd Jul 2026

BlogCursor • Chris Brauchli, Rikki Mukherjee & Kevin Niparko

Build from anywhere with Cursor for iOS

Cursor's native iOS app (public beta) to launch and steer coding agents from a phone.

Launch cloud agents or control local agents remotely.
Voice input plus slash commands.
Local ↔ cloud agent handoff.

View ↗

added by Adam Tomat • 30th Jun 2026

DocsAnthropic

Claude Code Subagents Run in the Background by Default

Resolved via search — verify before relying on it. Claude Code docs on running subagents concurrently in the background while you keep working in the main session.

Claude decides whether a subagent runs in the foreground or background based on the task, or you can ask it to run in the background (or press Ctrl+B).
Background subagents surface permission prompts in your main session, naming which subagent is asking.
Disable background tasks entirely with the `CLAUDECODEDISABLEBACKGROUNDTASKS` environment variable.

View ↗

added by Adam Tomat • 29th Jun 2026

BlogVercel • John Phamous

Teaching agents product design at Vercel

Vercel's repo-based skill that encodes product and design decisions for coding agents.

Design decisions encoded as a versioned skill.
Keeps agent-built UI consistent with the product.
The skill lives in the repo, next to the code.

View ↗

added by Adam Tomat • 26th Jun 2026

VideoWes Bos

Browsers and UIs are dead. Everything is chat (Wes Bos)

Wes Bos's JS Nation Amsterdam 2026 talk on agentic interfaces and Web MCP — pushing back on "chat replaces all UI".

Frames the "clicks vs clankers" tension: build AI into your site, or build your site so agents can use it directly.
Covers Web MCP as the mechanism letting agents use a site's existing capabilities instead of a bespoke chat UI.
Argues chat won't replace everything, but it reshapes the UI landscape.

View ↗

added by Adam Tomat • 25th Jun 2026

BlogAnthropic

Introducing Claude Tag

Resolved via search — verify before relying on it. Anthropic's Claude Tag turns Claude into a persistent team member inside a Slack channel, one that anyone can tag in and delegate work to.

One shared Claude per channel — everyone can see what it's working on and pick up where the last person left off, rather than each person having a private chat.
Claude remembers context from the channels it's in and can plan out and execute multi-step tasks using connected tools.
Launched in beta for Claude Enterprise and Team customers on Slack, running on Claude Opus 4.8.

View ↗

added by Adam Tomat • 24th Jun 2026

Repoopenclaw

openclaw/crabbox

A CLI that leases cloud/self-hosted compute, syncs your local diff, and runs commands/tests remotely.

~950 stars; a Go CLI plus a TypeScript coordinator.
40+ infrastructure providers supported.
Core loop: warm a box, sync the diff, run the suite — coordinator deployable on Cloudflare Workers.

View ↗

added by Adam Tomat • 24th Jun 2026

BlogDecoding AI • Paul Iusztin

Build, Configure, or Use As-Is: The Agentic Harness

Argues ~80% of agent harnesses are identical, so decide what to build vs configure vs use off-the-shelf for the other 20%.

Tools and catalogs are mostly YAML — configure, don't build.
Skills are markdown recipes; the memory layer is the piece worth custom-building.
Safety must live in a deterministic layer, not in prompts.

View ↗

added by Adam Tomat • 23rd Jun 2026

BlogDecoding AI • Alejandro Aboy

How Evaluation-Driven Development (EDD) Works for AI Agents

A pre-merge evaluation gate for AI agent changes, using simulated inputs run through the real agent.

An offline gate answering "does it work / did anything regress".
Simulate inputs (drawn from real traces), not outputs.
Rejects always-on prod eval as too costly; runs targeted branch experiments with calibrated binary judges.

View ↗

added by Adam Tomat • 23rd Jun 2026

BlogAddy Osmani

The New Software Lifecycle

Reframes the SDLC: agents are mostly harness, and verification moves to the centre.

Agents are roughly 10% model, 90% harness.
Static vs dynamic context load is a key design tradeoff.
The vibe-coding → engineering spectrum is defined by depth of verification.

View ↗

added by Adam Tomat • 23rd Jun 2026

BlogAnthropic

Claude Code Now Supports Artifacts

Resolved via search — verify before relying on it. A Claude Code beta feature that turns a coding session into a live, shareable web page hosted at a private URL, instead of a static export.

The page is built from real session context — codebase, connected MCP tools, terminal output — and updates in place as the session continues.
Artifacts can read from and write to connected MCP tools, so pages stay interactive rather than being one-off snapshots.
Beta access for Claude Team and Enterprise orgs, via the Claude Code CLI and desktop app.

View ↗