Glean 拾遗
Recent picks

51picks · chronological

09-03

Writing Code Is Easy. Reading It Isn't.

Drawing on years of contract work, the author argues that the real cost of software lives in reading, not writing: every codebase demands a mental model, built by tracing function definitions, return types, database paths, caches, error handling, and call sites. Understanding one getUserPreferences-like function often means opening five other files. Because LLMs can now emit code faster than anyone can consume it, they enlarge the reading burden; the lawyer who filed fictitious ChatGPT-sourced cases failed not at generating but at verifying through reading. The practical conclusion is to point AI at comprehension—explaining existing code, uncovering side effects, compressing context—rather than at producing bigger diffs. Team throughput should be measured by how quickly members construct accurate mental models, not by lines generated. A grounded opinion piece for engineers who want AI assistance without mistaking output volume for velocity.

idiallo.com · 6 min · AI Engineering · Developer Tools · LLM
09-01

Zod 4.5: z.compile() precompilation speeds parse up to 9x, slashes memory

Zod 4.5 introduces z.compile(), an AOT schema compiler that speeds up parsing of objects, arrays, and unions by ~3–9x. Combined with z.validate()—a fast boolean check that skips ZodError construction—invalid inputs are up to 16x cheaper to reject than safeParse. Benchmarks show 47.5M ops/s on the Moltar parseSafe fixture, ahead of typia's 45.3M. A move of bound methods to prototypes cuts per-schema heap retention by up to 9.8x. The release also includes breaking changes: string length now counts Unicode code points, z.iso.datetime() requires seconds, record keys and intersections match TypeScript semantics, and __proto__ is always stripped. Useful for TS teams doing heavy runtime validation in services, forms, and data pipelines.

zod.dev · 26 min · Developer Tools · Open Source · Performance
09-01

A Git-compatible VCS with a commit-centric workflow

Jujutsu (jj) is an open-source version control system written in Rust. It aims to make the everyday VCS workflow simpler while staying compatible with the Git ecosystem. The key design is a working copy that is automatically committed: every file change becomes a snapshot you can revisit or revert. An operation log records every state mutation, providing robust undo/redo. Conflicts are first-class data objects instead of inline text markers, making merges and rebases more predictable. jj can be used in existing Git repositories or as a standalone VCS, so it supports incremental adoption. This project is relevant for engineers exploring modern VCS design, Git workflows, and high-quality Rust-based tooling.

github.com · 2 min · CLI · Developer Tools · Rust
08-31

Why Claude Code outputs are moving from Markdown to HTML

The author argues that Markdown is too restrictive as an agent output format and documents his shift to HTML in Claude Code. HTML increases information density (tables, SVG, CSS, JS), makes long specs readable, is easier to share as a link, and supports two-way interaction via sliders or buttons. Use cases include exploration/specs, PR review with annotated diffs, design prototypes, research reports, and throwaway HTML editors that export 'copy as prompt' back to Claude Code. Trade-offs are acknowledged: generation is 2–4x slower, and HTML diffs make version control review harder. Full of concrete prompt examples for engineers working with agent workflows.

x.com · 14 min · Agent Engineering · Claude Code · Developer Tools
08-27

An agent skill that turns codebases into verifiable, interactive system maps

Archify is an agent skill that turns a system description or an entire repository into an interactive technical map. It supports five diagram types—architecture, workflow, sequence, data-flow, and lifecycle—and produces a single self-contained HTML file with built-in navigation, dark/light themes, finite motion, and exports to PNG, SVG, WebM, and 1200×630 share cards. Under the hood it uses a typed JSON IR as the source of truth, runs validation before delivery, and returns machine-readable repair receipts on failure. It also supports Before/Delta/After snapshots for architecture review. Designed for Raven, Cursor, Claude Code, Codex CLI, and OpenCode, it suits engineers and doc writers who want verifiable, shareable visualizations without hand-drawing.

github.com · 15 min · Agent Skills · AI Engineering · CLI
08-26

Claude Code for Startups: 5 Rules from AI-Native Teams

Anthropic interviewed a dozen fast-growing startups to extract five rules for using Claude Code: everyone ships; automate the tedium; trust but verify; build for rebuilding; and prototype, dogfood, productionize. Specific claims include Clay automating 100% of bug triage, ClickHouse's flaky-test agents becoming its second- and third-most-active repo contributors, and Cainex running a human-in-the-loop medical coding pipeline that revises agent instructions instead of patching individual examples. The guide bundles concrete mechanisms—MCP connectors, CLAUDE.md, skills, loops, hooks, dynamic workflows, and git worktrees—into a copy-paste checklist. It is vendor-produced and promotional in tone, but the operational details are unusually specific. Useful for startup CTOs and platform teams adopting agentic coding.

claude.com · 31 min · Agent Engineering · AI Engineering · Claude Code
08-26

Mutmut: A Python Mutation Testing System

The author, building Python libraries, realized that even 100% code coverage can miss boundary conditions and error handling. Mutation testing works by making tiny changes to source code (e.g., turning < into <=) and then running the test suite; if the tests still pass, the mutation is considered unkilled, revealing weaknesses. After evaluating Mutpy and Cosmic Ray, the author decided to write Mutmut from scratch. A key design choice was using the baron library (later replaced by parso) to enable lossless AST round-tripping, so mutations can be written back to disk without disturbing formatting. The author attempted to intercept module loading via import hooks to mutate in memory and parallelize, but abandoned this after discovering that the Python import system forces reimplementing every loader. The disk-based serial approach was kept for its simplicity and flexibility across test runners. Applied to tri.declarative and tri.struct, Mutmut found untested edge cases and dead code even with 100% coverage, genuinely improving the test suites. This is a first-hand, honest account for engineers interested in Python testing tooling.

kodare.net · 7 min · Developer Tools · Mutation Testing · Python
08-23

A beautiful, modern & opinionated Linux distribution by DHH

Omarchy is a Linux desktop distribution led by DHH, designed to deliver a beautiful and coherent out-of-the-box experience. It bundles a curated set of software—terminal, Neovim, AI tooling, TUIs, GUIs, browsers, and more—alongside unified hotkeys, clipboard history, reminders, and system utilities. Instead of a neutral base, it encodes the author's opinions directly into defaults, reducing configuration burden while keeping a consistent workflow. The repository version-controls install scripts, dotfiles, themes, and an extensive manual mirrored to a docs site, making the entire setup reproducible and auditable. It also includes agent-related files (AGENTS.md, skills) for AI coding assistants. Ideal for developers and creators who want a polished, opinionated environment without assembling one from scratch.

github.com · 2 min · Agent Engineering · Developer Tools · Dotfiles
08-22

Deterministic React code scanner that installs as an agent skill

React Doctor is a deterministic React code-quality scanner built for AI coding agents. It analyzes a codebase via CLI and flags issues across state/effects, performance, architecture, security, accessibility, and maintainability, including overly complex functions and repeated JSX that should be extracted. Instead of relying on LLM guesswork, it produces reproducible audit results. The findings can be installed as an agent skill for Claude Code, Cursor, Codex, OpenCode and similar tools, so the same rules guide future fixes. It also ships a GitHub Actions CI mode that only reports issues introduced by the current pull request, and can record Chrome performance traces for runtime hotspots. A good fit for teams whose React code is partially written by agents, or any engineering team that wants a low-noise React quality gate in CI.

github.com · 6 min · Agents · Code Review · Developer Tools
08-22

Introducing Delta: a multiplayer environment for coding with agents

Zed introduces Delta, a multiplayer environment for coding with agents, now in private beta. At its core is DeltaDB, which replicates both the conversation and the worktree in real time to every participant in a thread, while staying compatible with regular Git repositories. Every edit and conversation is captured between commits, so teammates who never open Delta still see a normal repo. Comments can anchor to any line of code and stay in place as the code evolves, connecting review to the conversation that produced it. The browser client is not a simplified port; it is the same Rust application compiled to WebAssembly and rendered through WebGL. Delta also integrates with third-party agent harnesses starting with Claude Code, syncing terminal sessions live into threads. The interface treats the conversation as an editable document, letting you place your cursor anywhere—on a diff line, a plan step, or a thinking block—and leave comments that the agent precisely understands. A product launch post with solid technical direction but limited hard data.

zed.dev · 7 min · Agent Tooling · Agentic Coding · Code Review
08-18

Handing Claude daily app maintenance: 388 PRs in weeks

The author has been experimenting with letting Claude take over day-to-day maintenance of their apps. A dedicated Slack channel runs Claude Tag daily across iOS, Android, Desktop, web, CLI, and Agent SDK: a crash fuzzer taps around in simulators to find and fix crashes, a dup unifier merges similar abstractions, a dead-code remover deletes unreachable code and logs suspects, and an abstraction police fixes leaky abstractions. In a few weeks the routines opened 388 PRs; 180 were merged after Claude Code Review plus human review. Claude usually gets PRs right first try, and when it doesn't, the author asks Claude to tune its own routines so they improve the next day. The post includes some actual prompts and a link to Claude Code routines for trying similar workflows.

x.com · 2 min · Agent Workflows · Automation · Claude Code
08-07

Introducing routines: scheduled cloud automations in Claude Code

Anthropic is adding routines to Claude Code in research preview. A routine packages a prompt, a repo, and connectors into an automation that runs on Anthropic's cloud, so nothing depends on your laptop staying open. There are three triggers: a schedule (hourly, nightly, weekly), an HTTP endpoint with its own auth token that returns a session URL, and GitHub repository webhooks that open a session per matching PR and keep feeding in follow-ups like comments and CI failures. The post sketches usage patterns—nightly backlog triage, docs drift scans, post-deploy smoke checks, Datadog alert triage—and documents daily caps: 5 routines for Pro, 15 for Max, 25 for Team/Enterprise, with extra usage billed beyond. Existing /schedule CLI tasks migrate automatically. Note this is a vendor launch post: it defines the feature surface but offers no benchmarks or independent evaluation.

claude.com · 5 min · Agent Engineering · Ai Tooling · Automation
08-04

The harness is all you need (mostly)

GitHub developer advocate Burke Holland argues that with AI coding, your biggest productivity lever is mastering the harness—the shared agent interaction/execution framework behind GitHub Copilot CLI, the Copilot app, and IDEs—not chasing new models, MCPs, or clever prompts. The post walks through a repeatable 8-step workflow: start with the Copilot CLI/App and enable YOLO mode (allow-all) inside a Codespaces sandbox; prototype aggressively with one prompt that generated 20 date-picker mockups in a single HTML file or Mermaid diagrams for API options; refine requirements in /plan mode (optionally with the 'grill-me' skill); implement in Autopilot, which automatically dispatches subagents like Explore on small models and General Purpose on larger ones; then iterate via human reviews and finish with a Rubber Duck review from a different model family (e.g., GPT-5.6 Terra asks Sonnet), optionally looping with /autopilot until diminishing returns. The article also advises keeping one model and reasoning level fixed to benefit from prompt caching, running YOLO mode only in sandboxes, and never settling for 'good enough' output.

github.blog · 16 min · Agent Engineering · Ai Tooling · Developer Tools
08-03

Stacked pull requests are now in public preview

GitHub introduces stacked pull requests in public preview, letting teams break large changes into an ordered series of small, focused PRs that can be reviewed and checked independently, then merged together in one click. The feature is available via the gh-stack CLI extension (gh extension install github/gh-stack), github.com, mobile, and GitHub Copilot through the gh-stack skill. Existing branch protections and required checks still apply; merge queue support is rolling out over the coming weeks. Early adopters include Vercel, TED, and WHOOP.

github.blog · 5 min · Code Review · Developer Tools
08-01

How OpenAI Engineers Use Codex: 7 Use Cases, 6 Workflow Practices

OpenAI published an official guide describing how its own security, frontend, API, infrastructure, and performance teams use Codex day to day. It covers seven use cases: code understanding, refactoring and migration, performance optimization, test coverage, development speed, staying focused, and exploration. The most actionable part is six best practices: start with Ask mode before switching to execution mode for large changes; maintain AGENTS.md to give Codex persistent context; write prompts like GitHub Issues, including file paths, component names, and diffs; use the Codex task queue as a lightweight to-do list; and use Best of N to compare multiple outputs. The guide quotes engineers with concrete claims, such as replacing every legacy getUserById() call and creating a PR in minutes, or overnight runs producing mergeable unit test PRs. It is vendor-authored, so it lacks failure cases and hard metrics, but the prompt templates and workflow tips are directly reusable for teams evaluating Codex.

openai.com · 14 min · Agent Engineering · AI Engineering · Codex
07-31

Vibe Coding Explained: Concepts, Examples, and Kimi's Tools

Kimi's official guide to vibe coding covers the concept, comparisons with traditional development, and five self-reported examples (resume scoring, portfolio site, admin dashboard, crypto profit simulator, plywood cutting planner), then shifts into a product tutorial for Kimi Websites and the terminal-first Kimi Code CLI. It includes concrete install commands, a sample prompt, and a three-step workflow, along with pros/cons and security caveats. Suitable for beginners who want to try Kimi's toolchain; experienced engineers may pick up basic Kimi Code usage, but the article lacks verifiable data or third-party comparisons and reads as product promotion.

www.kimi.com · 15 min · AI Engineering · Ai Tooling · CLI
07-31

AI Programming: Workflows, Tool Types, and Review Checklist

This article from Kimi positions AI programming as a code-centered workflow: instruction plus repository/runtime context, then generation with evidence. It categorizes tools into completion, assistant, agent, and review, and maps AI support across the SDLC. Benefits claimed include cross-file consistency, less context loss, reusable verification, and more time for engineering judgment. The second half is a product overview for Kimi Code, listing Plan mode, Skills, Hooks, MCP, and swarm mode. It closes with a practical four-point checklist before accepting AI-generated code: requirement scope, repository/security fit, independent evidence, and permission control. Useful as a framework for developers new to AI coding, but note that it is largely a launch piece, not a technical report.

www.kimi.com · 11 min · Agents · AI Engineering · Developer Tools
07-31

Agentic Coding, Explained: A Beginner's Guide With a Kimi Code Pitch

An official Kimi blog post presenting a beginner's guide to agentic coding, defining the plan-act-observe-revise loop and contrasting it with vibe coding. It argues agentic coding suits complex, multi-step, production-grade tasks with stronger developer control. The rest of the article is a promotional walkthrough for Kimi Code, a terminal-first coding agent powered by Kimi K3, including install commands, OAuth/API authentication, and a list of claimed benefits. No benchmarks, reproducible tests, or independent evaluation are provided, so it reads more like a landing page than a technical report. Useful only for a high-level overview; engineers seeking evidence to evaluate such tools will be disappointed.

www.kimi.com · 12 min · Agent Engineering · AI Engineering · Developer Tools
07-31

Official MCP server giving coding agents live Chrome DevTools control

chrome-devtools-mcp is the Chrome team's official Model Context Protocol server that lets coding agents drive a real Chrome browser. It exposes DevTools capabilities as 50+ MCP tools covering input automation, navigation, network inspection, performance tracing, heap snapshots, console debugging, screenshots, and more, and uses Puppeteer to reliably wait for actions to complete. Agents can also attach to an already-running Chrome to reuse session state. Built for engineers who want AI assistants to perform browser automation, frontend debugging, and performance analysis.

github.com · 46 min · Agents · Browser Automation · Developer Tools
07-29

Pi: All-in-One AI Agent Toolkit with Unified LLM API and Coding Agent CLI

Pi is an open-source AI agent toolkit offering a unified multi-provider LLM API (OpenAI, Anthropic, Google, etc.), an extensible agent runtime with tool calling and state management, an interactive coding agent CLI, and a terminal UI library. It addresses component fragmentation in building AI agents via modular npm packages, with containerization support and supply-chain security hardening. Ideal for engineers building, deploying, or customizing AI agents, especially coding agents.

github.com · 6 min · Agent Architecture · Agents · Ai Tooling
07-27

A Guide to Building Personal AI Infrastructure

This article presents a systematic guide to building a personal AI digital assistant based on Daniel Miessler's Personal AI Infrastructure (PAI) framework. The core thesis: don't start with tools, start with yourself. It covers the TELOS identity system (10 Markdown files defining mission, goals, beliefs, etc.), a three-tier memory architecture (hot/warm/cold), a decision priority chain (goal → code → CLI → prompt → agent), a user/system separation directory design, and an event hook system. It emphasizes that architecture matters more than model choice—a good context management system with an ordinary model often outperforms a top model without context. Suitable for engineers and knowledge workers who want to build a personalized, continuously learning AI assistant.

07-26

Ultrareview: Deep code review with remote sandbox agents

Ultrareview is a deep code review feature from Claude Code that launches a fleet of reviewer agents in a remote sandbox to find bugs in your branch or pull request. Compared to local review, it offers higher signal (each finding is independently verified), broader coverage (parallel agents), and no local resource usage. Use /code-review ultra from the CLI; supports base branch, PR number, and plain-word descriptions. Non-interactive subcommand claude ultrareview is available for CI. Billing: 3 free runs for Pro/Max, then $5–$25 per review. Diff limit: 500 files / 8,000 lines. Runs in 5–10 minutes. Useful before merging substantial changes.

code.claude.com · 9 min · Agents · Claude Code · Code Review
07-26

Why Harness Engineering Is So Hard

Based on five months of real-world experience (104 commits), this article dissects the structural difficulties of turning LLM demonstrations into reliable products. Key challenges include: inability to write deterministic tests (same input yields different output each time), silent and graded failures (1% error hidden in 99% correct output), debugging natural language paragraphs instead of code (a single adjective can be a bug), the additive instinct trap (prompt growing from 20 to 200 lines causes contradictions), examples steering harder than rules, unstable model foundation (vendor updates silently shift behavior), slow and expensive feedback loops, and invisible work (outsiders think it's just writing prompts). The author argues that harness engineering (prompts, validators, evals, guardrails) is the true moat, with difficulty stemming from the probabilistic nature of the substrate, which cannot be engineered away but only absorbed. Recommended for LLM app developers, AI engineers, and tech leads.

x.com · 16 min · AI Engineering · Developer Tools · LLM
07-23

Turn any codebase into a queryable knowledge graph, built for AI coding assistants

Graphify is an open-source tool that transforms codebases, docs, PDFs, images, etc. into a queryable knowledge graph. It uses tree-sitter for local deterministic AST parsing to extract code relationships (calls, imports, inheritance) without any LLM calls. Non-code files are semantically extracted via your AI assistant's model. The output includes an interactive HTML visualization, CLI queries (query/path/explain), and an MCP server for team use. Every edge is tagged EXTRACTED or INFERRED, providing transparency. Ideal for engineers navigating large monorepos, tracing dependencies, or understanding architecture.

github.com · 59 min · AI Agents · Developer Tools · Knowledge Graph
07-22

Local-first code intelligence graph for AI coding tools

code-review-graph is a local-first code intelligence graph that parses codebases with Tree-sitter and provides precise context to AI coding tools via the MCP protocol. It solves the problem of AI assistants re-reading large amounts of tokens during code review by performing blast-radius analysis to output only affected files. Features include 30+ MCP tools, incremental updates (<2s), a risk-scored GitHub Action for PR reviews, and support for custom languages. Benchmarks show median token reduction of 82x. Ideal for developers using AI coding assistants and teams maintaining large monorepos.

github.com · 36 min · Ai Tooling · Code Analysis · Code Intelligence
07-22

AI-Native Markdown IDE and LLM Wiki

Open Knowledge is an open-source, AI-native Markdown IDE that also serves as an LLM-powered wiki. It seamlessly integrates Markdown/MDX editing, personal knowledge management, and AI agents (like Claude and Codex) to help you build a second brain. Ideal for developers and knowledge workers who want intelligent note-taking and documentation.

github.com · 1 min · Agents · AI Engineering · Developer Tools
07-22

Kimi Code CLI: Terminal AI Coding Agent for Next-Gen Agents

Kimi Code CLI is an AI coding agent that runs in your terminal. It reads and edits code, runs shell commands, searches files, fetches web pages, and autonomously decides next steps based on feedback. It ships as a single binary with millisecond startup, features a purpose-built TUI, supports video input, AI-native MCP configuration, a rich plugin ecosystem, subagents for parallel tasks, lifecycle hooks, and ACP integration with editors like Zed and JetBrains. Ideal for developers seeking a powerful, extensible AI coding companion.

github.com · 4 min · AI Agents · CLI · Developer Tools
07-20

How to Build a Claude Code Skill That Actually Works (Full Guide)

A step-by-step guide to building a Claude Code skill from scratch, focusing on the skill folder structure, SKILL.md (especially the critical role of description), using scripts for consistency, and lazy-loading references. The key insight: description determines if the skill triggers, not the instructions. Practical for engineers using Claude Code to persist workflows.

x.com · 11 min · Agent Engineering · Ai Tooling · Claude Code
07-19

LangChain’s Open-Source Software Factory

LangChain open-sources four internal software engineering agent tools: local coding agent dcode, cloud coding agent OpenSWE, automated code review OpenSWE Review, and repo knowledge documentation OpenWiki. It includes real usage data (OpenSWE triggered ~1,000 times from Slack last week) and benchmark results (OpenSWE Review scores 47%, #1 among open-source tools). Built on Deep Agents framework with LangSmith observability. Targeted at engineers building controllable, observable agent pipelines.

x.com · 7 min · Agents · AI Engineering · Code Review
07-17

Graphify: Turn Any Codebase into a Queryable Knowledge Graph for AI Coding Assistants

Graphify is an open-source tool that transforms codebases, docs, PDFs, images, and videos into a knowledge graph for AI coding assistants like Claude Code, Cursor, and Gemini CLI. It uses tree-sitter AST for deterministic, local-only code parsing, and delegates semantic extraction for non-code assets to the assistant's model. The output includes an interactive HTML visualization, a Markdown report, and a reusable graph.json, enabling natural-language queries, path traversal, and concept explanations. Every edge is tagged EXTRACTED or INFERRED, so users always know what was read vs. guessed. Ideal for engineers onboarding large unfamiliar codebases or augmenting long-tail maintenance workflows.

github.com · 47 min · Agent Engineering · Ai Tooling · Code Intelligence
07-16

Cut Claude Code token costs by rendering system prompts & history as images

pxpipe is a local proxy that intercepts Claude Code API requests, rendering bulky text parts like system prompts, tool docs, and old history into compact PNG images. Since image token pricing depends on pixel dimensions rather than text length, the approach cuts input tokens by ~60%, leading to a 59–70% end-to-end cost reduction. It rewrites requests before they leave the machine, preserving prompt caching. By default it works with Claude Fable 5 and GPT-5.6, with dashboard controls for opt-in models. It includes profitability gates and benchmarks showing near parity in coding tasks, though exact-string recall is lossy. The project is aimed at developers using LLM coding agents who want to slash API costs without sacrificing functionality.

github.com · 12 min · Ai Tooling · Anthropic · CLI
07-16

The Short Leash AI Coding Method For Beating Fable

This post distills over a year of research on using AI agents for security-critical software. The author introduces the “Short Leash” method: only expert developers can use it; never enable YOLO mode; manually review every diff in the permissions prompt to keep the AI on track; commit after each subtask to safeguard against regressions. It also details AI-assisted code review: pair human and AI, with AI catching surface errors and humans guiding direction. PR authors must self-review line-by-line and disclose AI models used. This approach beats Fable even with non‑frontier models, without sacrificing quality. Targeted at senior engineers who want productivity gains without giving up understanding.

blog.okturtles.org · 7 min · AI Agents · AI Engineering · Code
07-15

How to Create Loops with Claude

This article advocates shifting from writing single prompts to designing loops—automated systems that keep AI agents working without human intervention. It breaks down a loop into six components: automation triggers, git worktrees for parallel isolation, skills (procedure manuals), connectors, sub-agents, and persistent memory files (e.g., STATE.md). The evaluator-optimizer pattern is highlighted: one agent generates, another verifies against objective gates like test suites or type checkers. Stop conditions must be checkable by external signals, not the agent's own claim. An autonomy ladder (suggest, draft, apply low-risk, full auto) helps gradually earn trust. The article also warns about token costs and the need for command allowlists in unattended loops.

x.com · 10 min · Agent Architecture · AI Engineering · Claude Code
07-14

Deep Comparison of AI Agent Skill Frameworks: Matt Pocock Skills, Superpowers, and Agent Skills

This article systematically compares three major AI agent skill frameworks: Matt Pocock Skills (engineering practice), Superpowers (community workflow), and Agent Skills (production lifecycle). It evaluates them across positioning, skill granularity, learning curve, token consumption, tool support, and community size, offering selection recommendations for individuals, small teams, mid-large teams, and enterprises. Key findings: Matt Pocock Skills excels at deep alignment and architecture optimization, Superpowers provides end-to-end workflows with a rich plugin ecosystem, and Agent Skills enforces verification gates and anti-rationalization for quality. It also suggests combination strategies. Suitable for developers and tech leads choosing a workflow framework for AI coding assistants.

www.besthub.dev · 8 min · Agent Engineering · Ai Tooling · Comparison
07-13

Lightweight terminal-based coding agent with local execution and cloud integration

Codex CLI is a lightweight coding agent from OpenAI that runs locally in your terminal, powered by your ChatGPT subscription or API key. Unlike IDE plugins or desktop apps, it offers a pure CLI experience tailored for terminal-centric developers. It supports macOS, Linux, and Windows and can be installed via shell script, npm, or Homebrew. Built with Rust and Bazel, it emphasizes performance and portability. Open-sourced under Apache-2.0, it's ideal for developers exploring command-line AI coding assistants.

github.com · 5 min · AI Engineering · CLI · Coding Agent
07-11

Agentic test processes: from chip design to AI workflows

Drawing from his experience at chip company Centaur, the author compares test processes that scale well with LLM agents: no code review by default, heavy reliance on fuzzing, and a dedicated test team. He argues that while LLMs are poor at writing tests directly, directed fuzzing with LLMs can find real bugs in minutes. The article highlights the high variance of LLM outputs—benchmark rankings often flip with minor task changes—and cautions against over-reliance on aggregated metrics. Through examples like building a superhuman board game AI, he advocates systematic data-driven iteration over prompt tricks. Targeted at engineers interested in AI-assisted development, testing, and agent workflows.

danluu.com · 91 min · AI Engineering · Benchmarks · Developer Tools
07-10

Rewriting Bun in Rust: 535K Lines, 11 Days, 64 AI Agents

Bun's creator Jarred Sumner recounts how he used Anthropic's Claude Fable 5 to rewrite Bun's 535,496 lines of Zig into Rust in 11 days. The motivation: Zig's manual memory management caused numerous use-after-free, double-free, and memory leaks when mixed with JavaScriptCore's GC. Instead of an incremental port, he orchestrated 64 Claude agents in parallel using dynamic workflows and adversarial review. 100% of Bun's test suite (over 600k assertions) passed on all 6 platforms. The rewrite fixed 128 bugs, reduced memory usage by up to 90%, shrank the binary by ~20%, and improved throughput by 2-5%. The article details the workflow, common porting mistakes (e.g., debug_assert! side effects, slice overruns, comptime format differences), and how Rust's Drop systematically prevented memory leaks. A first-hand account of using cutting-edge AI to accomplish a year-long team project in less than two weeks.

bun.com · 65 min · Agent Engineering · AI Engineering · Code
07-09

The /teach Skill

This article introduces the /teach skill, an AI agent skill designed for long-term, cumulative learning. Unlike one-off Q&A, /teach turns a directory into a persistent teaching workspace. It grounds lessons in vetted, high-trust resources (documentation, books) with citations, rather than relying on the model's parametric knowledge. It uses ADR-style learning records to track progress and dynamically adjusts lesson difficulty based on the zone of proximal development. The article details the workspace structure (lessons, reference, learning-records) and teaching philosophy: prioritizing storage strength over fluency illusion, and using desirable difficulty, retrieval practice, and spaced repetition for long-term retention. Ideal for engineers who want to learn a language, framework, or theory as a project over multiple sessions.

www.aihero.dev · 3 min · Ai Tooling · Developer Tools · Education
07-03

Local-first, agentic design workspace with 22 CLI agents and 150+ brand systems

Open Design is a local-first, open-source alternative to Claude Design. It is agent-native, meaning it doesn't ship its own agent but works with 22 coding-agent CLIs (Claude Code, Codex, Cursor, Copilot, etc.) already on your PATH. Using MCP, the agents read DESIGN.md brand systems, skills, and plugins to generate prototypes, live dashboards, decks, images, videos, and HyperFrames. Exports to HTML, PDF, PPTX, MP4. Supports BYOK for any OpenAI-compatible endpoint. Ships 100+ skills, 150+ brand-grade design systems, and 261 plugins. Ideal for engineers and designers who want brand fidelity and local control.

github.com · 35 min · Agent Engineering · Design Tools · Developer Tools
07-02

Building a Good Vertical Agent: Context as a Cache Hierarchy

The article argues that a good vertical agent is a faithful compression of its task distribution, and its context should be organized as L1/L2/L3 cache tiers. Using their Shortcut spreadsheet agent as example, they detail extreme optimizations: reading a range compresses 500 formulas into a single legend line via R1C1 normalization and aliasing; after writing, a structured diff groups, samples, and triages changes, flagging #REF! errors under MUST FIX. L2 provides curated English specs fetched on demand, like the pivot table recipe that bakes in gotchas (suspendLayout/resumeLayout, raw integer 8 for aggregation). L3 is the raw API reference plus a 100-line grep skill that lets the model mine tens of thousands of lines in bounded steps. The prompt budget mirrors the frequency curve, and the hierarchy moves as models improve. Practical, transferable advice for engineers building reliable agents in any domain.

06-27

Agentic Code Review

When coding agents produce thousands of lines of often solid code in minutes, the engineering bottleneck shifts from writing to trusting, making review the most leveraged skill in software. Multi-source 2026 data (Faros AI, CodeRabbit, GitClear, GitHub) shows: AI users generate ~4x raw output but only ~12% more delivered value; code churn up 861%, defect rate from 9% to 54%, review duration up 441.5%, and zero-review merges up 31.3%. The article argues the fix is not to stop using AI but to tier review effort by blast radius: light for solo no-user projects, heavy for large enterprises. Specific advice: triage PRs upfront, require evidence before review, watch test rewrites, run two differently-structured AI reviewers in parallel, and upgrade humans from line-level review to spot-checking and auditing. The durable skill is understanding a system well enough to stand behind it.

addyosmani.com · 29 min · Agent Engineering · AI Engineering · Code Review
06-27

The New Software Lifecycle: From Writing Code to Judging It

Key insights from a Google whitepaper on how AI transforms the software lifecycle. The core thesis: an agent is 10% model and 90% harness (instructions, tools, sandboxes, orchestration, observability). Context engineering is the primary cost lever, with a critical distinction between static context (loaded every turn, reliable but expensive) and dynamic context (loaded on demand, cost-efficient but needs careful design). Verification determines whether you're vibe coding or doing agentic engineering: tests for deterministic parts, evals for non-deterministic output and trajectory. Real data: one team moved a coding agent from outside top 30 to top 5 on Terminal Bench 2.0 by changing only the harness with the same model; LangChain added 13.7 points on the same benchmark by changing system prompt, tools, and middleware around a fixed model. Implementation collapses from weeks to hours, while specification and verification become the new bottlenecks. For engineers and tech leads adopting AI agents in production workflows.

addyosmani.com · 15 min · Agent Architecture · AI Engineering · Context Engineering
06-26

ECC: Cross-Harness Agent Operating System for Claude Code, Cursor & Beyond

ECC is a comprehensive agent harness operating system designed to enhance multiple AI coding assistants including Claude Code, Cursor, Codex, OpenCode, and GitHub Copilot. It's not a standalone AI tool but a collection of 260+ skills, 67+ agents, persistent memory, continuous learning, cost optimization, and security auditing features. By providing unified rules, hooks, and MCP configurations across platforms, it addresses issues of inconsistent agent behavior, context loss, and inadequate security. Ideal for professional developers deeply using AI coding assistants and teams seeking standardized agent engineering practices.

github.com · 94 min · Agent Engineering · Claude Code · Context Engineering
06-22

The Debug Loop: How Claude Code Finds the Bug in 6 Steps Instead of 60

Most developers debug with Claude Code by pasting errors and accepting speculative fixes, leading to a 40-60 message death spiral. This post proposes a six-step loop: first establish a reliable repro (failing test), isolate the search area in plan mode, dispatch read-only subagents to trace root causes from multiple angles, fix only the root cause (not symptoms), verify with an automatic hook (e.g., PostToolUse running the test), and keep the repro as a permanent regression test. The key insight is that Claude Code was always capable; the failure mode is skipping straight to 'fix' before understanding the bug.

x.com · 7 min · Agent Engineering · Claude Code · Debugging
06-22

Vercel's AI Design Spec: A Textbook Example

This article deeply analyzes Vercel's DESIGN.md, showcasing how to write an efficient and executable design specification for AI. It breaks down Vercel's approach across color, spacing, typography, motion, copy, and accessibility, revealing the thinking behind it. The color system uses a 100-1000 scale where each number corresponds to a fixed UI state (default, hover, click), eliminating AI guesswork. Spacing is limited to 9 values based on 4px increments, enforcing rhythmic consistency. Typography adopts role-based thinking (heading/label/copy/button) instead of pixel-based thinking. Motion design advocates 'no animation is often best' and gives precise durations per scenario. This piece is valuable for product managers, front-end engineers, and AI tool developers aiming to improve AI-generated UI consistency or build their own design specs.

x.com · 4 min · Ai Tooling · Design System · Developer Tools
06-21

Ponytail: Lazy Senior Dev Inside Your AI Agent, Cuts Code Bloat by ~54%

Ponytail is a rule plugin for 14+ AI coding agents (Claude Code, Codex, Copilot CLI, etc.) that injects a lazy-senior-dev mindset. Before generating code, it forces the agent to climb a ladder: does this need to exist? Can the standard library or native platform feature do it? Can it be one line? Only then writes the minimum viable solution. Benchmarked on real Claude Code sessions editing a real FastAPI + React repository across 12 feature tickets, it cuts lines of code by 54% (mean), tokens by 22%, cost by 20%, and time by 27% while keeping 100% safety on validation, error handling, security, and accessibility. Ideal for developers tired of AI bloat and over-engineering.

github.com · 12 min · Agents · AI Engineering · Code Generation
06-21

A local HTML editor built for human-AI collaboration

Lavish-axi is a local CLI tool that opens AI-generated HTML artifacts in a local browser, allowing developers to annotate elements, select text, take screenshots, and send structured feedback directly back to the AI agent. It runs a local server with a browser chrome, supporting live reload, layout auditing (overflow, clipped text, overlapping text), feedback queuing, and long polling. Built as an AXI, it requires no setup beyond `npx` and can be integrated as a skill into agents like Claude Code. It's ideal for engineers who need to iterate on AI-generated visualizations, plans, or UI mockups with precise feedback.

github.com · 18 min · Agents · Ai Tooling · CLI
06-08

Composable Agent Skills for Real Engineering Workflows

Matt Pocock's personal agent skills for Claude Code and Codex, targeting four common failure modes in AI-assisted development: misalignment, verbosity, broken code, and design entropy. Instead of controlling the process, these small, composable skills embed engineering fundamentals—grilling sessions for alignment, shared ubiquous language for concision, TDD red-green-refactor loops for code quality, and architecture rescue tools. They work with any model and are designed to be hacked and adapted in your own .claude directory.

github.com · 14 min · Agents · AI Engineering · Claude Code
06-08

Every Agentic Engineering Hack I Know (June 2026)

The author shares 22 practical hacks for agentic engineering with Claude Code and Codex. The core is a plan-first workflow: use /ce-plan to generate a plan.md that guides the agent; humans skim or ask inline instead of reading it. Hacks include: voice input via Monologue or Wispr Flow (LLMs handle imperfect transcription); running 4-6 separate agent sessions in cmux tabs; defaulting terminal tabs to Claude Code and bypassing all permission prompts with sound alerts on completion; giving Claude an email address via AgentMail to trigger sessions remotely; using last30days before planning to search community discussions and news in parallel; turning repeated tasks into reusable skills to compound agent capabilities. He stresses that human value lies in providing taste and direction, not typing, and warns against AI addiction. The post is packed with copy-paste config snippets and concrete tools, aimed at engineers deep into AI-assisted development.

x.com · 28 min · Agent Infrastructure · Agents · AI Engineering
06-07

Weekly AI Roundup: Claude Limits Doubled, SpaceX IPO, Microsoft Model Data Contradiction

A roundup of 10 major AI and tech news items from the first week of June 2026. MiniMax M3 was released, beating GPT-5.5 on coding benchmarks at $0.6/M tokens, though independent verification is pending. DeepSeek raised ~$7.4B in its first external funding round, while Unitree completed its IPO review in a record 73 days. Kimi Work, Coze 3.0, and Qwen3.7-Plus all launched new Agent capabilities. Doubao announced subscription plans. ChatGPT surpassed 1 billion monthly active users. Anthropic doubled Claude Cowork's usage limits, secretly filed for an IPO, and published a report stating Claude writes 80% of its own code. NVIDIA unveiled the ARM-based RTX Spark at Computex. SpaceX is set to IPO on June 12, with Google disclosed paying $920M/month for compute. Microsoft's MAI-Thinking-1 faced backlash after its claimed 'clean data' was revealed to include Common Crawl, and GitHub Copilot's switch to metered billing caused developer bills to spike.

mp.weixin.qq.com · 7 min · AI Engineering · AI Industry · Cost Optimization
06-02

A Multi-Agent IDE to Run Claude Code, Codex, and Others in Parallel Git Worktrees

Orca is a desktop and mobile IDE designed to run multiple AI coding agents—such as Claude Code, Codex, and Grok—concurrently. It leverages Git's worktree mechanism to give each agent an isolated working directory, eliminating the need for stashing or branch juggling. Users can observe and control all agents from a single interface with tabbed panes, built-in diff review, and direct GitHub Issue/PR integration. It's built for developers who rely on CLI-based coding agents and need to handle multiple features or refactors in parallel.

github.com · 9 min · Agents · Ai Tooling · CLI