Coding Agents

How a TypeScript daemon and a native Swift sidecar turned everyday messaging apps into a local-first AI control plane.

As AI agents move from chat boxes to terminal roots, a new architecture is emerging to govern their instincts, skills, and security.

How functional TypeScript and terminal state serialization built a provider-agnostic coding agent immune to vendor lock-in.

How a Rust-based CLI uses the Model Context Protocol and autonomous agents to write, test, and maintain its own repository.

How an accidental source code leak spawned an open-source AI agent framework that is now autonomously rewriting its own core in Rust.

A tiny Claude plugin turns Karpathy’s anti-overengineering rules into a practical workflow for minimal diffs, test-driven execution, and fewer AI self-inflicted wounds.

A system of skills, workflows, and state files that pushes coding agents toward TDD, triage, and rigorous decision-making instead of loose prompt-following.

The Rust runtime matters, but the real innovation is the parity machinery that makes an AI coding agent observable, testable, and easier to reason about.

dsh turns documentation, translation, and architectural decisions into enforced runtime discipline, then wraps it in a plugin system built for modular agent infrastructure.

A cross-agent ruleset that turns lazy senior developer instincts into enforced behavior, with hooks, modes, and benchmarks that keep LLMs from overengineering the answer.

How Jesse Vincent built a skills-and-hooks system that makes coding agents follow plans, write tests, delegate work, and review themselves like a real software team.

A sprawling prompt archive that reads less like a leak and more like unofficial documentation for the new AI operating system.

A collection of `DESIGN.md` files that turns brand aesthetics into context for coding agents, replacing the blank page with a reusable visual language.

How Garry Tan’s open-source framework turns Claude Code from a simple autocomplete tool into a multi-role software factory with persistent visual QA.

How a ruthlessly disciplined TypeScript monorepo replaces fragmented AI wrappers with a unified runtime, type-safe reasoning, and a high-performance terminal UI.

How JuliusBrussee/caveman strips filler from Claude Code, Cursor, Windsurf, and more, while using validation and lifecycle hooks to keep terse output technically safe.

How microsoft/generative-ai-for-beginners bridges the gap between raw prompts and production-grade agentic systems across 50 languages.

A deep look at the sandbox, microagents, and canvas that turn a coding bot into an operating layer for software work.

How a standardized protocol and its reference implementations are ending the fragmented era of proprietary LLM tool integrations.

A monorepo that makes LLMs interchangeable, agent loops durable, and long-running coding sessions survivable.

How openai/codex disguised a high-performance Rust orchestration server as a terminal tool, and accidentally created a cross-platform standard along the way.

How a recursive "Planner-Executor" architecture and a fleet of parallel sub-agents are turning the terminal into an autonomous engineering department.

How a "Planning-as-Code" framework solves context rot and turns Claude into a spec-driven lead engineer.

A deep dive into the skill-based orchestration layer that turns coding assistants into video producers, from reference-video reverse engineering to cost-aware model routing and frame-accurate rendering.

A native AI workspace for developers, built around local execution, MCP extensions, and a surprising idea: when a plugin fails, let the agent help debug the plugin.

How a fintech company built a Rust-native, local-first AI agent that safely executes shell commands without compromising the host machine.

A Google-built MCP server that turns browser debugging, performance tracing, and runtime inspection into tools an agent can actually use.

A terse-speech skill for coding agents, a file-compression pipeline, and safety rails that make brevity useful instead of reckless.

A 20-phase, multi-language course that turns lessons, quizzes, artifacts, and agent skills into one executable learning system.

A file-system-native framework for scraping roles, scoring fit, drafting tailored applications, and forcing an AI reviewer to challenge the result before it becomes a PDF.

How a modular library of "Agent Skills" is turning technical IDEs into autonomous growth departments.

A community-built system for skills, agents, commands, hooks, and permissions, with audio telemetry that lets developers hear autonomous work happen.

A plugin, skill, and MCP stack that pushes Claude past chat and into governed financial modeling, deck checking, and audit-ready document generation.

A deep dive into the Stanford NLP framework that replaces manual prompt hacking with signatures, modules, and optimization loops.

A deep dive into the open-source framework that distills mental models, decision heuristics, and expression DNA into portable Claude Code skills, complete with source checks and explicit limits.

A look at the open-source agent harness that keeps context alive, permissions explicit, and model choice optional.

A deep dive into the Python client that turns a moving API into a typed, async-ready, production-friendly interface without sacrificing ergonomics or correctness.

How an open-source project bypassed the AI editor wars by injecting high-performance autonomous coding directly into the IDEs developers already use.

A shell-driven hierarchy of agents, skills, hooks, and gates gives solo developers something closer to a staffed production pipeline than a prompt box.

How an open-source framework replaces ad-hoc prompt engineering with a multi-agent, self-documenting software development lifecycle.

A deep dive into the repo that treats HTML as a rendering engine, bakes design judgment into `SKILL.md`, and exports the same artifact to web, slides, and video.

How the 800-million-byte C++ behemoth is wiring LLMs directly into its workflow to manage technical debt and fend off lightweight challengers.

A meta-programming system for Claude Code that adds confidence gates, self-checks, long-term memory, and parallel execution so an AI session behaves more like a disciplined development workflow than a loose chat.

By turning the page into a structured action space, Jev-Ultrafast replaces slow screenshot-and-reason loops with typed, guarded, one-shot decisions.

How a deterministic middleware layer uses the Language Server Protocol to give AI agents surgical precision.

Claude Code Best turns a leaked terminal agent into a modular TypeScript system with feature flags, native hooks, and provider flexibility.

How Google Labs turns a design system into structured Markdown that agents can read, lint, resolve, and export without losing the brand logic.

Prime Agent is built for long-running work, not one-off prompts. Its recursive sub-agents, continual harness, and persistent IPython kernel turn agentic coding into a background system you can reattach to and refine.