AI Hero's skills repo ships v1.1, renaming /to-prd to /to-spec, merging /to-plan and /to-issues into /to-tickets, and adding new Skills like /wayfinder, /research, and /prototype.
Why it matters: The author walks through the full Skill flow from grilling to deployment and gives the migration commands for the renames, the merge, and the new /wayfinder—useful for anyone building an AI development workflow.
At Prime Radiant, author Jesse Vincent used Claude Code—working through the Slackline command-line Slack client—to collaborate with his own agent Ada: Claude proposes changes, Ada reviews and tests them, then Claude deploys the updates, forming a development loop where the agents review each other.
Why it matters: By looping two agents through mutual review, testing, and deployment, the author shows a transferable model for collaborative agent-based development.
Augment launches Project Builder on the Cosmos platform. This Cosmos expert turns a one-line feature description into a design doc grounded in the real codebase; after human review, it orchestrates worker agents to implement the work and drive it to merge.
Why it matters: Augment has shared how Project Builder handles design review and orchestration, plus the code volume and launch timelines of three production projects—enough to judge whether design-first plus agent orchestration is workable.
Inside Claude Code, Anthropic has already built up hundreds of Skills in active use. The team sorts them into nine categories—library and API references, product validation, data fetching and analysis, business process automation, code scaffolding, code quality and review, CI/CD and deployment, runbooks, and infrastructure operations—and notes that the best Skills should fall cleanly into one of them.
Why it matters: Anthropic’s internal framework for categorizing hundreds of Skills, along with its experience writing them, can carry over to a team building its own Skill library.
Anthropic has shipped dynamic workflows in Claude Code. Claude can write its own harness on the fly for a specific task, and these workflows can be shared and reused. Workflows orchestrate subagents through functions like agent(), parallel(), and pipeline(), and you can specify which model each agent uses and whether it runs in its own worktree. If a session is interrupted, resuming it picks up where it left off.
Why it matters: The Anthropic team breaks down six orchestration patterns for dynamic workflows and where each one fits, and these patterns carry over to multi-agent task design.
Cloudflare built a CI-native AI code review system on top of the open-source coding agent OpenCode. A coordinating agent dispatches up to 7 dedicated review agents, split by security, performance, code quality, documentation, release, and internal standards, then deduplicates their output and posts a single structured review comment.
Why it matters: Cloudflare has published the plugin architecture, risk grading, and cost data behind its multi-agent code review in CI, and the setup can be ported to your own review pipeline.
Augment wires the Incident Investigator expert from its internal Cosmos platform into Slack and PagerDuty. It automatically triages every alert and runs root-cause analysis, then suggests one of four actions: fix the code, roll back, upgrade, or just keep monitoring. Humans only review the RCA and make the call.
Why it matters: Augment has shared the full playbook for putting Cosmos Expert on alert triage, along with a month of before-and-after data, so you can adapt it to your own on-call process.
Starting with Codex 0.128.0, OpenAI offers Goals, turning one-off prompts into persistent objectives within a thread. Codex keeps checking evidence such as tests, benchmarks, or deliverables to decide whether the goal is done.
Why it matters: The official docs lay out where Goals fits, how to write its six elements, and the lifecycle commands, so you can tell when a persistent objective should replace a one-off prompt.
Augment Code pulled dozens of AGENTS.md files from its own monorepo and used its internal benchmark suite AuggieBench to compare how the same tasks performed with and without the file. The best files delivered a quality boost equivalent to upgrading from Haiku to Opus, while the worst made the output worse than having no AGENTS.md at all.
Why it matters: Augment Code used internal benchmarks to quantify how much the different ways of writing AGENTS.md actually differ, so readers can adjust their own repo's documentation structure accordingly.
After analyzing the architecture that surfaced in the Claude Code source leak, the author argues that its core isn't a secret algorithm but a while loop plus a tool dictionary in under 30 lines of Python, driven by stop_reason !
Why it matters: From the leaked source, the author distills 12 composable agent-engineering patterns and lays out a four-week path to get started, useful for checking your own implementation for gaps.
Based on the Claude Code source code that leaked unexpectedly last week, Drew Breunig mapped out how the system prompt is assembled: components fall into two categories—always included and conditionally included—and shift based on toggles like output_style, repl_mode, user_type_ant, skills_enabled, and mcp_connected.
Why it matters: The author breaks down the dynamic assembly logic behind Claude Code's system prompt, showing how conditional context engineering works in practice.
The author used the open-source multimodal Qwen 3.5 series models for PDF OCR: first exporting each page as an image at 100 dpi with PyMuPDF, then feeding the images to the model for recognition. In testing, Qwen3.5-9B hit the sweet spot between quality and speed, while the smaller 0.8B to 2B models tended to go off track on complex documents, summarizing the content instead of transcribing it.
Why it matters: The author tested Qwen 3.5 models of various sizes for PDF OCR, and shares two reusable paths—local and via OpenRouter—along with cost data.
A Martin Fowler team article breaks down context engineering for coding agents, sorting context configuration into reusable prompts (instructions and guidelines), context interfaces (tools, MCP Servers, Skills), and workspace files. It then splits these by "who decides what gets loaded" into three categories: the LLM, the human, and the agent software.
Why it matters: Using Claude Code as an example, this piece walks through how to configure context for coding agents and lays out the trade-offs between loading on demand and building up gradually.
OpenAI's developer blog explains how to systematically test Codex Agent Skills with evals, turning "it feels better" into comparable scores.
Why it matters: It lays out a complete workflow for systematically validating Codex Skills with evals, from defining success criteria to deterministic checks and scoring.
When developing web apps with the coding agent, the author often runs into client-side JavaScript bugs. If the agent can't fix them by reading the code, it fires up browser MCP for interactive debugging just to see the browser console logs—burning tokens and slowing things down.
Why it matters: The author shares a reusable front-end/back-end log bridge approach that lets the coding agent see front-end logs without browser MCP.
In the Codex Cookbook, OpenAI lays out a complete workflow for modernizing a legacy codebase with Codex CLI, using a COBOL portfolio system as the example and moving through five phases built around an ExecPlan design document.
Why it matters: Using a COBOL portfolio system as the example, it offers reusable documents and a validation workflow for modernizing legacy code in phases with Codex CLI.
Author Jesse Vincent spent an afternoon porting Superpowers and the whole SKILL.md system to the OpenAI Codex CLI, shipping it with Superpowers 3.3.0.
Why it matters: The author ported Claude's SKILL.md system to the Codex CLI, with tool mappings and install instructions, so you can judge whether reusing Skills across models is feasible.
Anthropic rolled out its first-party Skills system simultaneously on Claude Code, Claude.ai, and the Claude API, and author Jesse Vincent quickly followed with a new version of Superpowers built on the official Skills.
Why it matters: Drawing on nearly a month of hands-on use, the author compares the official Skills with his own setup and lays out the trade-offs involved in migrating.
Author Jesse Vincent released Superpowers, a set of Skills built on Claude Code's new plugin system. Once installed, it injects a guiding prompt through the session-start hook, prompting Claude to proactively search for and use these Skills.
Why it matters: The author packaged his own coding-agent workflow into an installable Skill plugin, so readers can directly reuse his implementation flow from brainstorming to TDD.
The author walks through their full workflow with Claude Code: first isolating tasks with git worktree, then using a brainstorming prompt to make Claude ask only one question at a time and confirm the design in stages, and finally using a planning prompt to break the plan into small tasks and write them into docs/plans/.
Why it matters: The author splits Claude Code into two sessions—an architect and an implementer—and shares reusable prompts plus a git worktree approach for isolating tasks.
Anthropic's applied AI team argues that context engineering is a continuation of prompt engineering, and the core idea is picking the smallest set of high-signal tokens within a limited attention budget.
Why it matters: Anthropic lays out a systematic approach to context engineering, covering the trade-offs among three long-task strategies: compression, note-taking, and sub-agents.
The author rewrote a long block of CLAUDE.md rules as a GraphViz dot flowchart, using quoted strings as node names, different shapes to distinguish decisions, commands, and warnings, and giving each flow an explicit trigger condition.
Why it matters: After rewriting the CLAUDE.md rules as a GraphViz dot flowchart, Claude followed the rules better, and this approach can be carried over to your own projects.