This post goes one layer further out. Once an agent has a harness and a way to load Skills, the next question is more practical: how does it reach the production systems it needs to do real work?

Anthropic’s post, Building agents that reach production systems with MCP, is about exactly that. It compares direct API calls, CLIs, and MCP, then explains why production agents increasingly land on MCP: agents are moving to the cloud, the systems they need are remote, and auth, discovery, and rich interaction need a common layer. Anthropic says they are seeing this across more than 200 MCP servers, millions of daily Claude users, and fast-growing MCP SDK usage.

Share

The original post is written as practical guidance for MCP servers and clients. I am taking a slightly different angle: the pattern view. What are the reusable shapes behind the advice? What problems do they solve? When should you use them? And what are the trade-offs? I see 12 core patterns spread across five groups.

Tool surface

The shape of your tool set is the first architectural choice, and it is rarely “one tool per endpoint.” Three default moves cover the span from small services to hundreds-of-endpoints monsters.

1. Remote-First Server Pattern

The first foundational architectural choice for an MCP server is where it runs.

Local MCP servers over stdio work only when the agent can spawn a child process on the same machine: desktop Claude, local IDE agents, and some CLIs. That excludes agents running in browsers, mobile apps, or cloud execution environments, which is where most production agent traffic is heading.

Build the server as a remote HTTP endpoint from day one, not as a local-only module the team might “put on the network later”. Every other production concern in this post (auth, elicitation, discovery) assumes the server is reachable over the network. A local-only server has to rebuild each of those the moment it needs to scale beyond the local machine.

Remote-first also makes distribution portable. One server, one auth flow, many clients. No per-client bundle to ship, no machine-level install to maintain.

When to use. Any time the agent on the other side might not run on the same machine as the server. In practice, this is the default for most production integrations.

The main trade-off. Network transport raises the bar on reliability, latency budgeting, and auth. You have to engineer a public surface where a local process would have been enough, and you carry the operational weight of every internet-facing service.

2. Intent-Grouped Tools Pattern

This is probably the most common MCP server design mistake: exposing one tool per API endpoint. It feels like the fastest and most faithful implementation, but it creates the wrong interface for agents.

The agent does not think in API endpoints. It thinks in tasks. A 1:1 API wrapper leaves the agent assembling long chains of primitives. More tool definitions in context, more round-trips per task, more ways to get the chain wrong.

Group tools around user intent, not around the endpoints they happen to hit.

A single create_issue_from_thread tool is better than

get_thread + parse_messages + create_issue + link_attachment.

The agent goes from a four-call chain to a one-call intent, and each intent is something a human reviewer can reason about directly.

The implication is that your MCP server is not a proxy. It is a new surface. Expect to write wrapper tools that compose multiple endpoints, normalise half-formed IDs, retry on rate-limited calls, and return the output the agent will actually use, not the output the endpoint happened to produce. Anthropic has a companion post on writing effective tools that covers the craft details.

When to use. Default for any service with roughly fifty or fewer tools. When you find yourself inventing a fifth parameter to keep tool count down, you have probably outgrown this pattern.

The main trade-off. Every new intent is new code on your side, not a schema export. The server stops being a thin translation layer and becomes a product surface you have to design, test, and version.

3. Thin Surface Pattern

Some services have hundreds, sometimes thousands, of operations: Cloudflare, AWS, Kubernetes. Even grouped by intent, the full toolset blows past what fits in context, and any given agent task touches only a sliver of it.

Drop the intent-grouped model and expose a deliberately thin surface that accepts code. Two tools suffice: a search tool that lets the agent find the right API operation, and an execute tool that runs a short script written by the agent against the underlying API in a server-side sandbox. Only the result returns to the model.

Cloudflare’s MCP server is the reference implementation: two tools cover roughly 2,500 endpoints in about 1,000 tokens of definitions. The agent gets the full expressive power of the API without paying to have every operation described upfront. The sandbox contains the blast radius. Scripts cannot reach past what the server hands them. This pattern compounds with Programmatic Tool Calling on the client side: the client processes results in its sandbox, the server executes calls in its sandbox, and raw data never needs to reach the model.

When to use. When an intent-grouped surface would need more than roughly thirty to fifty tools to be useful, or when the underlying service is API-shaped (Cloudflare, AWS) rather than intent-shaped (Linear, Slack).

The main trade-off. You inherit sandbox operations. Script isolation, resource limits, timeout policies, and API-key handling inside the sandbox are all your problem. The agent has more power, which means you have more to defend.

Interaction Semantics

A tool that only returns text pushes the UI problem to the model. That is fine for small answers, but a poor fit for dashboards, tables, forms, previews, confirmations, and anything else the user needs to inspect or act on.

MCP adds interaction primitives that let the server take back some of that responsibility. Instead of asking the model to describe everything in prose, the server can return UI, ask for structured input, or hand the user to an external flow when needed.

4. Inline UI Pattern

A tool that returns a wall of JSON leaves the user reading compressed prose about their own data. For anything dashboard-shaped, such as charts, tables, forms, and interactive confirmations, the agent is the wrong rendering layer.

Ship UI with the tool response. MCP Apps let the server return an interactive interface that the client renders inline in chat: charts, forms, dashboards, and mini-views built from your product’s real components.

The bar is not “build a full web app.” The bar is simpler: if the tool’s result is something a user wants to look at rather than hear described, return a view, not a paragraph. Your product’s design system is more readable than any Markdown the model can synthesise.

When to use. Any tool whose output is fundamentally visual or tabular: search results, dashboards, file previews, status views.

The main trade-off. You now ship UI alongside your API, which means component versioning, accessibility, and design review. The MCP server is no longer backend-only.

5. Elicited Input Pattern

Agents hit real-world ambiguity constantly: missing parameters, destructive actions that need confirmation, multiple matches that need disambiguation. The usual fallback is to guess, or to ask the user to restart the conversation with more detail. Both cost trust.

Pause the tool call and ask the user directly. MCP elicitation, specifically Form Mode, lets the server return a form schema mid-call. The client renders it natively. The user fills it. Control returns to the server, and the tool completes.

This keeps the user in the flow instead of sending them back to model output with “please specify the region.” The agent’s job stays the same; the server gets to be honest about what it does not yet know.

When to use. When the missing information is structured, such as a region, an ID, or a confirmation, and the user is the only source of truth.

The main trade-off. Every elicitation is a UX moment your server now owns. Poor form design turns a helpful pause into an annoying interrogation, and the pattern is untested in headless or batch agents where no human is available to fill it.

6. External Handoff Pattern

Some steps should never transit the MCP client at all. Downstream OAuth against a third party, taking a payment, collecting a credential that the agent’s context window must not see. If the client sees it, your threat model just widened.

This is not for authorizing the MCP client to access the MCP server. That belongs to MCP authorization. URL Mode is for sensitive downstream flows the server needs to complete on the user’s behalf.

Hand the user to a browser URL with URL-Mode elicitation. The server returns a link; the client opens it in the user’s browser; the user completes the sensitive flow out-of-band; control returns to the server once it is done. The MCP client never sees the secret. This is the right shape for downstream OAuth, payments, or any credential that should never transit the MCP client.

The distinguishing question between this and Form-Mode elicitation is where the secret lives after the interaction. Data the server can legitimately hold goes to Form Mode. Data a third party should hold goes to URL Mode.

When to use. Third-party OAuth flows, payments, and anything governed by compliance rules that say the credential never hits your infrastructure.

The main trade-off. The user leaves the agent interface. Every handoff is a chance for them to drop off, and you have to design resume-after-redirect cleanly.

Auth and Credential Flow

Production agents run in the cloud, against systems protected by OAuth. Two patterns replace custom per-server authentication with standard plumbing.

7. Discoverable Auth Pattern

Every MCP server that invents its own auth adds friction at install time: configuration screens, token pastes, stale credentials. First-time failure rates climb, and re-auth prompts wear users down.

Publish and support standard OAuth metadata so the client can discover how authentication should work. For client registration, MCP supports Client ID Metadata Documents: the client uses an HTTPS URL as its client_id, and that URL points to a JSON document describing the client, its redirect URIs, and related metadata.

The practical effect: a user adds the server, the client discovers the auth flow, OAuth starts with the right client metadata, and the user does not have to paste tokens or manually configure client IDs.

When to use. Every production MCP server with user-scoped data. It is not optional if the goal is cross-client adoption.

The main trade-off. You are committing to standard OAuth behavior rather than a shortcut that works only for your own client. That means metadata endpoints, scope discipline, redirect URI validation, token validation, and the operational discipline to keep the flow working across clients.

8. Vault-Held Credentials Pattern

Even with discoverable auth, OAuth tokens still need a home. If every MCP server handles tokens directly, every integration ends up rebuilding the same secret store, refresh loop, rotation policy, and revocation path.

Offload token lifecycle to a platform vault. In Claude Managed Agents, OAuth credentials can be registered once, referenced by vault ID at session creation, and injected into the right MCP connections by the platform.

The practical effect: the MCP server does not need to receive tokens in tool calls or implement its own token storage. Refresh, revocation, and credential handling move one layer up.

When to use. Whenever you are shipping on a managed-agent platform that offers a vault. At a minimum, design your server so that credentials could be injected from one. Do not bake token handling into tool calls.

The main trade-off. You are trusting a platform vault with production credentials. Its uptime, security posture, and export policy become part of your production story. Self-hosted servers outside a managed platform have to rebuild the pattern themselves.

Context Economy

The agent’s context window is finite. Two client-side patterns keep it lean even when the tool population and tool results are large.

9. On-Demand Tool Loading Pattern

A client connected to several MCP servers can easily have hundreds of tool definitions in play. Loading all of them upfront blows the context budget before the first tool even fires.

Load tool definitions lazily through a tool-search meta-tool. The agent searches for tools by description; only matching definitions are loaded into context; everything else stays out. Tool search can cut tool-definition tokens significantly while maintaining high selection accuracy (docs).

This is the client-side complement to Intent-Grouped Tools and Thin Surface on the server side. Good server design keeps the total tool count manageable. Good client design keeps only the needed subset in context.

When to use. Any agent with more than a handful of tool sources, or any cross-cutting task that might touch tools from several MCP servers.

The main trade-off. The search step adds a round-trip and depends on description quality. Tools with vague descriptions will not surface when they should, and the cost of a miss is the agent picking a neighbouring tool that looks close.

10. Programmatic Tool Calling Pattern

Tool results, such as long lists, nested JSON, logs, traces, or large document payloads, often land in the model’s context window raw. The agent pays tokens to read them, even when the task is only to filter, count, aggregate, or join the data.

Process tool results in a code-execution sandbox before they reach the model. Programmatic tool calling lets the agent loop, filter, and aggregate across calls in code, with only the final useful output entering context. The same idea is described in more detail in the engineering post on code execution with MCP.

This cuts token usage on complex multi-step workflows and compounds with On-Demand Tool Loading. Fewer tool definitions go in, less raw data comes back, and the model reasons over the result rather than the full payload.

When to use. Multi-step workflows that chain several tool calls and transform results before the model needs to see them.

The main trade-off. You need a sandbox environment, sandbox debugging, and a mental model that includes code the agent writes against your results. Simple single-call tools do not benefit.

Packaging and Distribution

A server on its own is rarely the whole integration. Two patterns ship servers with the skills, hooks, and subagents that make them useful.

11. Plugin Bundle Pattern

A real integration rarely ships as a single MCP server. It is usually an MCP server plus a Skill that teaches the agent how to use it, a subagent for specialised work, and hooks for lifecycle events. Distributing them separately creates configuration drift and version skew.

In Claude Code, ship them as one plugin. Plugins bundle Skills, MCP servers, hooks, LSP servers, and specialised subagents into one distribution unit. One install, one version, one name.

The data plugin for Cowork is a good reference example: 10 Skills and 8 MCP servers covering Snowflake, Databricks, BigQuery, Hex, and more, installable as a unit.

When to use. Whenever your integration needs more than a bare MCP server to be genuinely useful, which in practice is most real-world integrations.

The main trade-off. Bundling couples release cadences. An update to any component ships the whole plugin, and teams with independent release cycles per component will feel the drag.

12. Server-Distributed Skills Pattern

An MCP server gives the agent access to tools, but access is not the same as expertise. The server provider usually knows the best workflows, safe sequences, common mistakes, and domain-specific conventions. Without a way to share that knowledge, each client has to rediscover it, and each agent has to improvise.

Ship Skills from the MCP server itself. The client gets both the raw tool access and the procedural knowledge for using those tools well. In practice, the server does not only expose capabilities; it also ships the playbook for using them. Canva, Notion, and Sentry already do this in Claude today.

The MCP community is working on a portable extension so that Skill delivery can work across compliant clients, versioned with the API the Skill depends on. Today the pattern is client-specific; the experimental extension makes it protocol-level.

When to use. When your MCP server wraps a surface rich enough that “how to use it well” is a real Skill, not a one-paragraph hint.

The main trade-off. Experimental today. Early adopters of portable server-distributed Skills commit to spec changes; sitting out means losing the adoption advantage that comes with shipping expertise alongside capabilities.

The takeaway

These patterns are not only about MCP as a protocol. They show the shape production agent integrations are starting to take:

• MCP servers are becoming agent-facing product surfaces. The useful ones expose intent-based tools, not endpoint mirrors. They hide API choreography, return agent-ready outputs, and sometimes return UI instead of prose.

• Interaction is moving beyond text. The server can ask for structured input, request confirmation, show inline UI, or hand the user to an external flow when secrets, payments, or third-party auth are involved.

• Auth is becoming standard plumbing. Discoverable OAuth flows and vault-held credentials move production agents away from custom token handling inside every tool call.

• Context is now an architectural constraint. Tool definitions need on-demand loading, and large tool results need filtering, joining, and aggregation before they hit the model. Otherwise, the context window becomes the bottleneck.

• Distribution is becoming richer than “ship an MCP server.” Real integrations include servers, Skills, hooks, subagents, and product-specific playbooks. The raw capability matters, but the instructions for using it well matter just as much.

Some of these extensions are still early, and the patterns will keep evolving. But they are already visible in real MCP usage, and several are gaining traction across production servers and clients. That is why they are worth naming.

If you want to read the earlier parts of this series, start with these two posts:

• 12 Agentic Harness Patterns from Claude Code

• Skill Authoring Patterns from Anthropic’s Best Practices

Skills come in two rough types. Task skills (often as disable-model-invocation: true) are step-by-step workflows (deploy, commit, security-review) that a user often invokes directly via /skill-name. Reference skills (user-invocable: false) are passive knowledge (style guides, domain vocabulary) that Claude applies inline whenever a relevant request matches. Most of the patterns below apply to both, but where emphasis shifts I will call it out.

The 14 patterns fall into five categories: discovery and selection, context economy, instruction calibration, workflow control, and executable code.

Discovery and selection

Two patterns decide whether a skill fires at all. At session start Claude sees only metadata: the name and description of every installed skill. A skill that cannot survive this metadata-only round never runs.

1. Activation Metadata pattern

With dozens of installed skills, Claude picks the wrong one, or none at all, when descriptions are vague like “helps with documents”. The description field is not just a summary; it is the only signal Claude has at selection time.

This pattern packs the description with both what the skill does and the specific triggers or contexts that should fire it, written in third person. Anthropic’s skill-creator goes further and recommends writing descriptions that are a little “pushy”, since Claude has a measured tendency to under-trigger skills: “Make sure to use this skill whenever the user mentions dashboards, data visualization, or internal metrics, even if they do not explicitly ask for a dashboard.”

Use this pattern on every skill. Nothing else matters if the skill fails at selection. The trade-off is budget: in the open Agent Skills spec, the description field caps at 1024 characters; in Claude Code, the combined description and optional when_to_use text is truncated at 1536 characters in the skill listing. So every sentence competes with positive triggers, exclusion clauses, and domain keywords for space.

2. Exclusion Clause pattern

A description that only says when to fire misses half the job. The skill triggers on tangentially related requests, hijacks work that belongs to another skill, or steps in when bare Claude would have done fine.

This pattern ends the description with explicit exclusions: “Do NOT use for blog articles, newsletters, emails, tweets, or long-form content.” Ruben Hassid calls this the single most important line in the description, above the positive trigger. Positive triggers pull a skill in; exclusions push it out. Both are needed and they compete for the same budget.

Use this for any skill that shares vocabulary with other skills or with bare Claude (most of them). The trade-off is maintenance: as your skill library grows, exclusion clauses must be kept in sync so two skills do not both claim or both reject the same territory.

Context economy

Two patterns exist because the context window is a shared budget. Every token in your skill crowds out tokens from other skills, the conversation history, and the user’s actual request.

3. Context Budget pattern

A skill that re-explains what a PDF is, what a library is, or how JSON works spends tokens teaching Claude things Claude already knows. Multiply that waste across a library of 20 skills and the context window is half-full before the user has said anything.

This pattern demands each paragraph justify its token cost. Default assumption: Claude is smart. If removing a sentence would not confuse a competent reader, remove it. Consistent terminology matters too: pick one term (always “field”, never “field / box / element”) to reduce cognitive load. And avoid time-sensitive phrasing (”before August 2025...”) that dates the skill; put legacy information in an “old patterns” appendix instead.

Use this pattern on every skill; it is a baseline discipline. The trade-off shows up with less-capable models: what reads as crisply concise to Sonnet may be too terse for Haiku. If you target multiple models, aim for the level of detail that works for the weakest one you plan to support.

4. Progressive Disclosure pattern

Stuffing every detail into SKILL.md burns context on material most invocations never need. An 800-line SKILL.md with forms, API references, and examples costs the same whether the user asked about forms or about something else entirely.

This pattern treats SKILL.md as a table of contents. The body stays under 500 lines and links to domain files (FORMS.md, REFERENCE.md, reference/finance.md). Claude reads the metadata on every session; loads SKILL.md only when the skill is triggered; and pulls in detail files only when the current task references them. Scripts in scripts/ can execute without loading, so their internal code usually stays out of the context window. Keep the reference graph shallow: every file one hop from SKILL.md. Nested chains like SKILL.md -> advanced.md -> details.md increase the odds Claude only partially reads the target and misses the rest. Long reference files, especially those over a few hundred lines, get a table of contents at the top so Claude can see the full scope even from a truncated read.

Use this for any skill pushing past ~300 lines in SKILL.md. The trade-off is fragmentation: splitting content across files makes it harder for authors to hold the whole skill in their head, and Claude has to make correct routing decisions about which file to load next. Mis-routing costs turns.

Instruction calibration

Five patterns dial instruction specificity up or down. Control Tuning is the meta-rule for how tightly to constrain Claude. Explain-the-Why shapes how that specificity is phrased. Template Scaffold, In-Skill Examples, and Known Gotchas are concrete techniques at the low-freedom end of the dial.

5. Control Tuning pattern

A skill that rigidly scripts every action strangles Claude on tasks where context should shape the approach. A skill that gives only loose guidance fails on fragile procedures where one wrong step breaks everything.

This pattern matches instruction freedom to task fragility. High freedom (text instructions, “use your judgement”) fits open-field tasks like code review where many valid approaches exist. Medium freedom (pseudocode, parameterised scripts) fits preferred-but-flexible flows like a deploy runbook. Low freedom (exact scripts, no flags, “do not modify this command”) fits fragile operations like database migrations where one wrong step is catastrophic.

Tone is part of the dial too: opening with a persona (”You are a senior code reviewer focused on correctness over style”) sets the judgement rubric for the whole skill and is common in reference skills that shape voice.

Use this pattern by asking, for each step in the skill, how much variance is acceptable. The trade-off is judgement: authors consistently err toward over-constraining, because rigid instructions feel safer. They are not; they just fail differently.

6. Explain-the-Why pattern

Skills written as strings of ALWAYS, NEVER, MUST in capital letters give Claude rigid rules with no context. The model follows the letter but misses edge cases the author did not anticipate, or over-applies a rule in situations where a judgement call was needed. Anthropic’s skill-creator explicitly flags all-caps MUST/ALWAYS/NEVER as a yellow flag to reframe.

This pattern states the rule, then explains why so Claude can generalise to cases the skill did not spell out. “Use constructor injection. Field injection breaks testability because we cannot mock the field without Spring context” beats “MUST use constructor injection. NEVER use field injection.” The reasoning becomes the rubric for unanticipated cases.

Use this pattern wherever you catch yourself reaching for capitalised imperatives. The trade-off is length: explanations cost tokens, and for genuinely fragile steps (see Control Tuning), a bare imperative is still correct. Reserve prose-with-reasoning for the cases where Claude will need to exercise judgement.

7. Template Scaffold pattern

When output structure matters, reports, commit messages, API payloads, release notes, Claude produces inconsistent shapes across invocations. The shape is implicit in examples elsewhere, but the skill does not make it explicit, and each run rediscovers a slightly different structure.

This pattern ships a template in the skill body with placeholders Claude fills in. Templates come in two strictness levels. Strict: “ALWAYS use this exact template structure” for data contracts or machine-parsed output. Flexible: “A sensible default; adapt sections as needed” for documents where the author trusts Claude to judge.

Use this whenever output structure has downstream readers or parsers. The trade-off is creative flatness: strict templates suppress the structural variation that can make output more useful in edge cases, so prefer flexible templates unless a machine is reading the output.

8. In-Skill Examples pattern

Description alone rarely conveys tone, formatting conventions, or the right level of detail. Claude hits the right shape but the wrong style: commit messages that use the correct conventional-commit prefix but miss the tone the team writes in.

This pattern embeds concrete input/output pairs in the skill body, the same few-shot trick used in prompting. Two or three examples, each labelled Input: and Output:, show the desired pattern directly. Claude matches on the examples instead of inferring from prose. Templates (previous pattern) show the skeleton; examples show populated instances. The two compose well, with the template defining shape and examples calibrating style.

Use this for skills where output quality depends on style as much as structure: commit messages, release notes, changelog entries, review summaries. The trade-off is drift toward the examples. If the three examples share a subtle bias, Claude reproduces that bias across all invocations, so the examples need to span the variation the skill should support.

9. Known Gotchas pattern

Skills that document only the happy path teach Claude what to do, not what to watch for. The first time the skill hits a real-world edge case, a form field that does not exist, a command that works on macOS but fails on Linux, a library that silently returns empty results, Claude has no prior and invents a fix.

This pattern adds a dedicated section to SKILL.md listing concrete failure modes previously seen: “Scanned PDFs return [] silently. Check page type first.” “Rotated pages need page.rotation=0 before column extraction.” One practitioner guide calls the gotchas section the most valuable content of a mature skill.

Use this pattern on mature skills, populated from observing real runs. The trade-off is that gotchas are a moving target: libraries update, APIs change, and a stale gotcha can send Claude chasing a problem that no longer exists.

Workflow control

Three patterns structure multi-step procedures. Execution Checklist is the linear case. Self-Correcting Loop introduces iteration. Plan-Validate-Execute adds a verifiable artifact before any side effects.

10. Execution Checklist pattern

In long multi-step procedures Claude skips validation steps, loses track of which step it is on, or declares done prematurely. “I think we are finished” at step four of a six-step process is a common failure mode.

This pattern provides a copyable checklist Claude pastes into its response and ticks off as it works. The checklist lives in the conversation, so skipping a step is now visible to both Claude and the user. The act of rendering unchecked items each turn raises the bar for declaring completion.

Use this for any workflow with more than three steps, especially where a skipped validation step is costly. The trade-off is verbosity: the checklist is rendered in full on every turn, so in long sessions it multiplies tokens, and for very short flows it is overkill.

11. Self-Correcting Loop pattern

When Claude generates code, edits XML, or drafts against a style guide, a single forward pass often ships mistakes the skill could have caught. The skill describes the correct output but has no mechanism to verify what Claude actually produced.

This pattern wires in an explicit loop: produce output, run a validator, if it fails, fix and revalidate. The validator can be a script (python validate.py fields.json) or a document (re-read STYLE_GUIDE.md and check each rule). The loop terminates only when validation passes.

Use this for quality-critical tasks where mistakes are expensive and programmatic verification is feasible. The trade-off is non-termination: a weak validator (or a Claude that keeps making the same mistake) can loop indefinitely, so the pattern needs a retry cap and a fallback to the user.

12. Plan-Validate-Execute pattern

For batch or destructive operations, updating 50 form fields, migrating rows, rewriting a document, a direct “just do it” pass lets errors cascade silently. By the time you notice Claude referenced non-existent fields, the changes are already applied.

This pattern inserts a verifiable intermediate artifact, typically a JSON plan, between understanding the task and acting on it. A script validates the plan before any side effects. That is the distinction from Self-Correcting Loop, which iterates after the work has already landed. Claude iterates on the plan freely; the real target is only touched once the plan passes validation.

Use this for batch, destructive, or high-stakes operations. The trade-off is ceremony: for a two-field edit the plan-validate-execute loop is more process than the task deserves, so reserve it for operations where “undo” is costly or impossible.

Executable code

Two patterns apply to skills that ship runnable helpers alongside SKILL.md. Together they shift work out of Claude’s inference loop and into deterministic scripts that run, succeed or fail, and return only their output.

13. Utility Bundle pattern

Asking Claude to generate a validation script, a PDF extractor, or a data-normaliser from scratch every invocation is slower, less reliable, and burns tokens on code the user never sees. Each run rediscovers the same logic with small variations.

This pattern ships purpose-built scripts in scripts/ alongside SKILL.md. Claude invokes them via bash, so only their output consumes context. Scripts should handle common failure modes cleanly instead of dumping ambiguity back on Claude. Sometimes that means creating a missing file with a sensible default. Sometimes it means failing fast with a clear error. Constants need justifying comments (”30s timeout covers slow connections”), not magic numbers. When in doubt about which helpers to bundle, run the skill on three test cases and read the transcripts: if subagents all wrote the same helper independently, promote it to scripts/.

Use this for any operation that is deterministic, frequently repeated, and worth testing independently. The trade-off is environment dependence: scripts need a runtime, and platform-specific helpers fail differently on user machines than on the author’s, so validate package availability in SKILL.md and prefer forward slashes in every path.

14. Autonomy Calibration pattern

A skill that runs with the full default tool set can do anything: write files, shell out, call MCP servers, even when its task only needs read access. A security-audit skill with Write and Bash permissions is still a standing risk, regardless of what SKILL.md says.

This pattern declares an allowed-tools list in the skill’s YAML frontmatter to pre-approve only the capabilities it actually needs. A security audit gets Read, Grep, Glob; a documentation generator gets Read, Write; a deploy skill gets Bash with a narrow command matcher. That reduces approval friction, but it does not by itself restrict which tools are available. In Claude Code, actual restrictions come from permission rules, not from allowed-tools alone.

Use this for any skill where a narrow pre-approved tool set is genuinely sufficient, especially security, audit, review, and analysis skills. The trade-off is confusion: an over-broad allowed-tools list quietly grants more hands-off autonomy than intended, and it is easy to mistake pre-approval for sandboxing. If you need real restrictions, pair this with permission rules.

The takeaway

These 14 patterns are essential. The description field decides whether the skill even runs; progressive disclosure decides how much context it costs; explain-the-why and known gotchas decide whether Claude handles the edge cases; plan-validate-execute and autonomy calibration decide how much can go wrong when something breaks. Each pattern addresses a failure mode that shows up across authors and domains.

As with the harness patterns in the previous post, these are not product-specific tricks. They are becoming the cornerstones of how agents get extended, and they will remain relevant as the models and tools change underneath them.

The source material for this post is Anthropic’s own Skill authoring best practices, their skill-creator SKILL.md (Anthropic eating their own dog food), the 33-page Complete Guide, plus community writing from Akshay Pachaar, Ruben Hassid, Tort Mario, Alex Xu, and Siva.

The patterns fall into four categories: memory and context, workflow and orchestration, tools and permissions, and automation.

Memory and Context

These five patterns form a progression: from giving the agent a static file of rules, to scoping those rules by directory, to organizing memory into tiers, to cleaning that memory in the background, to compressing the conversation itself when the context window fills up.

1. Persistent Instruction File Pattern

Without a persistent instruction file, every agent session starts blank. The user repeats the same conventions, commands, and boundaries each time. The agent makes the same mistakes in session five that it made in session one.

This pattern introduces a durable project-level configuration file loaded automatically at the start of every session. It defines build commands, test commands, architecture rules, naming conventions, and coding standards. It ships with the repo, not with the user’s clipboard.

Use this when your agent works on a codebase across multiple sessions. The main trade-off is the maintenance burden: the file must stay current as the project evolves, and a stale instruction file can be worse than none if it teaches the agent outdated rules.

2. Scoped Context Assembly Pattern

A single instruction file works for small projects. As a codebase grows, one file either becomes a giant blob that gets ignored, or stays too generic to be useful for any specific directory.

This pattern loads instructions dynamically from multiple files at different scopes: organization, user, project root, parent directories, and child directories. The agent sees different rules depending on where in the codebase it is working. Import syntax allows splitting large instruction sets across files without duplication.

Use this in monorepos, multi-language projects, or any codebase where different directories follow different conventions. The main trade-off is discoverability: when instructions live in many files, it becomes harder to understand what the agent actually sees. Conflicting rules across scopes can produce surprising behavior.

3. Tiered Memory Pattern

An agent that remembers everything the same way ends up remembering nothing well. Loading all memory into the context window every session wastes tokens, hits size limits, and buries useful information under noise.

This pattern organizes agent memory into distinct layers with different loading strategies. A compact index (capped at 200 lines in Claude Code) stays in context at all times. Topic-specific files load on demand when the current task matches them. Full session transcripts stay on disk and are only searched when needed. One of the most detailed breakdowns of the leaked code confirmed this three-layer design.

Use this when your agent runs across multiple sessions and needs to retain preferences, decisions, or workflow state. The main trade-off is the added complexity in deciding what goes where, when to promote or demote information between layers, and how to keep the index in sync with the underlying files.

4. Dream Consolidation Pattern

Even with tiered memory, agent memory degrades over time. Duplicate entries accumulate, outdated facts contradict new ones, and the index grows until it is no longer compact.

This pattern runs a background process that periodically reviews, deduplicates, prunes, and reorganizes agent memory during idle time. Think of it as garbage collection for agent state. The leaked code revealed an “autoDream” mode that merges duplicates, prunes contradictions, and keeps the index tight. A separate analysis found 8 phases of memory management and 5 types of context compaction.

Use this when your agent accumulates memory across many sessions and you cannot rely on users to curate it manually. The main trade-off is that the consolidation process itself uses tokens and can make mistakes. An overly aggressive prune might delete something the user still needs.

5. Progressive Context Compaction Pattern

Long agent sessions eventually hit the context window limit. The agent either loses its earliest context entirely or stops working. Neither is acceptable for tasks that require sustained reasoning across many turns.

This pattern applies multiple stages of compression tuned for different ages of the conversation. Recent turns stay at full detail. Older turns get lightly summarized. Very old turns get aggressively collapsed. The leaked code used four layers: HISTORY_SNIP, Microcompact, CONTEXT_COLLAPSE, and Autocompact, each progressively more aggressive.

Use this when sessions regularly exceed 20-30 turns. The main trade-off is lossy compression: every summarization step discards detail, and if the agent later needs something from a collapsed segment, it may hallucinate rather than admit it forgot.

Workflow and Orchestration

The common theme here is separation: separating reading from writing, research context from editing context, and sequential work from parallel work. These patterns matter because the default behavior of most agents is to mix everything together, and that mixing degrades quality as the task grows.

6. Explore-Plan-Act Loop Pattern

When an agent jumps straight to editing files, it makes changes based on incomplete understanding. The result is edits to the wrong files, missed dependencies, and approaches that ignore existing patterns.

This pattern separates the workflow into three phases with increasing write permissions. In the explore phase, the agent can only read, search, and map the codebase. In the plan phase, it discusses the approach with the user. Only in the act phase does it get full tool access. The leaked code showed distinct plan and act phases with system prompts that steer the agent away from editing before it understands the codebase.

Use this for any task that touches an unfamiliar codebase or involves non-trivial changes across multiple files. The main trade-off is speed: enforcing exploration and planning adds turns before the agent produces output, which feels slow for simple tasks.

7. Context-Isolated Subagents Pattern

In a long agentic session, the context window accumulates everything: research findings, planning discussions, code edits, test output, error logs. By the time the agent is deep into editing, its context is polluted with irrelevant material from earlier phases.

This pattern runs separate agents with their own context windows, system prompts, and restricted tool access. Research agents cannot edit code. Planning agents cannot execute commands. Each subagent sees only what it needs for its specific task.

Use this when sessions are long, multi-phase, or involve tasks with very different context needs. The main trade-off is coordination overhead: the main agent must decide what to pass to each subagent, and important nuance from an earlier phase can get lost in the handoff.

8. Fork-Join Parallelism Pattern

Large tasks that could be split into independent units still run sequentially if the agent can only work on one thing at a time. A migration across 20 files takes 20 sequential steps even though most of those files have no dependencies on each other.

This pattern spawns multiple subagents in parallel, each working in an isolated git worktree on an independent copy of the repo. The parent’s cached context is reused by each fork, making parallel branching essentially free in token cost. Results merge when all branches complete.

Use this when a task decomposes into independent units that do not depend on each other’s output. The main trade-off is merge complexity: when parallel branches touch overlapping files, the merge can produce conflicts harder to resolve than sequential work would have been.

Tools and Permissions

If the memory patterns are about what the agent knows, and the workflow patterns are about how it works, these patterns are about what it is allowed to do. The leaked code showed a level of tool design and permission granularity that goes well beyond what most agent frameworks implement today.

9. Progressive Tool Expansion Pattern

Giving an agent access to every available tool at once creates a selection problem. With 60 tools visible, the model spends more time deciding which to use and is more likely to pick the wrong one.

This pattern starts with a small default set (fewer than 20 tools in Claude Code) and activates additional tools on demand. Justin Schroeder noted the deliberately small default set. The agent starts with Read, Edit, Write, Bash, Grep, Glob, and a handful of others. MCP tools, remote tools, and custom skills activate only when needed.

Use this when your agent has access to many tools but most tasks only need a few. The main trade-off is that the expansion logic adds complexity: the harness must decide when to activate tools, and activating too late means the agent wastes turns without the right capability.

10. Command Risk Classification Pattern

Letting an agent run arbitrary shell commands without inspection is dangerous. But asking the user to approve every command creates fatigue, and users end up clicking “yes” to everything.

This pattern applies deterministic pre-parsing and per-tool permission gating before execution. Each tool has individual allow, ask, and deny rules with pattern matching. Shell commands pass through a classification layer that parses the verb, flags, and target to assess risk. The auto-mode classifier found in the code auto-approves low-risk actions while keeping a safety classifier for anything dangerous.

Use this when your agent can execute shell commands or interact with external systems. The main trade-off is rigidity: a deterministic classifier cannot anticipate every safe or dangerous command, so the rules need ongoing tuning.

11. Single-Purpose Tool Design Pattern

When an agent routes every file operation through a general shell (cat, sed, grep, find), the commands are harder to review, harder to permission, and harder for the model to use correctly. A sed command that edits a file looks identical in structure to one that corrupts it.

This pattern replaces the general shell with purpose-built tools for each common operation: FileReadTool, FileEditTool, GrepTool, GlobTool. Each tool has typed inputs, a constrained scope, and its own permission rules. Raschka calls this out explicitly: the harness provides “predefined tools with validated inputs and clear boundaries” rather than allowing improvised commands.

Use this when your agent performs common file and search operations frequently. The main trade-off is flexibility: purpose-built tools cannot cover every edge case, so you still need a general shell as a fallback.

Automation

The final pattern stands alone because it cuts across all other categories. It addresses a problem that applies equally to memory, workflow, and tools: the model cannot be trusted to remember procedural steps that must happen every time.

12. Deterministic Lifecycle Hooks Pattern

Some actions must happen every time without exception: run the formatter after every edit, validate commands before execution, reload configuration when the working directory changes. Relying on the model to remember these through prompt instructions is unreliable. The model will forget, skip, or reinterpret the instruction depending on context pressure.

This pattern runs shell commands or other actions automatically at specific points in the agent lifecycle, outside the prompt entirely. The leaked code includes 25+ hook points such as PreToolUse, PostToolUse, SessionStart, and CwdChanged. Anything that must happen every time belongs in a hook, not in an instruction.

Use this when you have invariant behaviors that should never be skipped. The main trade-off is debugging difficulty: when something goes wrong in a hook, it can be harder to diagnose than a prompt-level instruction because hooks run outside the conversation.

The Takeaway

I believe these patterns are not temporary tricks or product-specific features. They are cornerstones of agentic harness design. Memory tiering, context compaction, permission gating, lifecycle hooks: these are the kinds of architectural decisions that will remain relevant as the models and tools evolve underneath them.

The Claude Code leak gave us a rare opportunity to see how these patterns are implemented at the cutting edge, in a production agent used by hundreds of thousands of developers. That visibility will not last, but the patterns will.

The leak handed everyone a blueprint for how a production coding agent is assembled. That blueprint is more interesting than the drama around it, and this post is about the practical lessons I took from it, things Claude Code users and agent builders can apply.

What happened

If you want a video walkthrough, Matthew Berman’s coverage is the fastest entry point. Anthropic confirmed this was a release packaging mistake caused by human error, not a hack. No customer data, API credentials, or model weights were exposed.

One surprising detail, noted by Justin Schroeder, is that much of the system prompting lives in the client-side source rather than behind a server-side API. For a company like Anthropic, shipping prompts, which are important IP, inside a distributed npm package was unexpected. The codebase is TypeScript and React with Bun bindings, and the code is full of comments written for LLMs, not humans, so that agents working on the codebase can understand each section. A technical breakdown at ccunpacked.dev mapped the full structure.

What happened next

The code escaped almost immediately. Mirrors spread across GitHub, takedowns followed, and community rewrites appeared within hours.

The most visible follow-on project was Claw Code, presented as a clean-room Python rewrite of the harness. The repository now includes a Rust port and frames itself as “better harness tools” rather than an archive of leaked code. That “clean-room” phrasing matters, but it is not a magic legal shield. Whether a rewrite is actually lawful depends on how it was produced, not on what the README says.

There is also a security warning. BleepingComputer reported fake GitHub repositories using the leak as bait for infostealer malware. Attackers also registered malicious npm packages targeting anyone who tried to compile the leaked source. The sensible stance: study the incident, learn from it, do not run random “leaked Claude Code” repos.

The more interesting signal is how quickly open-source projects started absorbing the patterns. You can see it directly in OpenCode’s issue tracker, where users asked whether the harness design should be incorporated. The community treated the leak as a public architecture review, not gossip.

What Claude Code users can learn from this

Below are ten lessons. They are useful whether you use Claude Code or you are building your own agentic application.

1. Treat CLAUDE.md like a config file

The leak confirmed that CLAUDE.md is not an optional README. It is a control file loaded at the start of every session. A community analysis showed how the harness treats it as persistent project memory that shapes every interaction. Build commands, test commands, architecture boundaries, naming rules. It all belongs there.

Run /init once to generate a starting version, then edit it by hand. A good CLAUDE.md reads more like a .eslintrc than a README:

# CLAUDE.md

## Build & test
- Run tests: `npm test`
- Lint: `npm run lint`
- Build: `npm run build`

## Architecture rules
- All API handlers go in `src/api/`
- Never import from `src/internal/` outside that directory
- Use Zod for all request validation, no manual parsing

## Conventions
- Use `snake_case` for database columns, `camelCase` for TypeScript
- Every new endpoint needs a test in `tests/api/`

If you are building your own agent, the same principle applies. Give it a structured instruction file that loads every session, not a prompt you paste each time.

2. Keep memory selective, not exhaustive

One of the most detailed breakdowns of the memory system showed a three-layer design: MEMORY.md as a compact index always loaded into context, topic-specific memory files loaded on demand, and session transcripts only searched when needed. Auto memory is capped at the first 200 lines. The code also revealed an “autoDream” mode, a background process that consolidates memories during idle periods, merging duplicates, pruning contradictions, and keeping the index tight. A separate mem0 analysis found 8 phases of memory management and 5 types of context compaction.

The takeaway: memory should be curated. Store stable preferences, recurring workflow hints, and things that are not obvious from the code. Do not store stack traces, logs, or facts Claude can derive by reading the repo. If a memory note would not help in a future session, it should not exist.

3. Split instructions by scope

The leaked code showed context assembled from multiple files dynamically, not crammed into one prompt. Claude Code supports multiple instruction scopes: org-level, user-level, project root, local overrides, parent and child directories.

Keep one short root CLAUDE.md with broad project rules. Put language-specific or module-specific instructions closer to the code they govern.

4. Explore first, then plan, then code

The leak revealed how seriously Anthropic treats the separation between planning and execution. The harness has distinct plan and act phases, and the system prompts steer the agent away from editing before it understands the codebase.

In practice: first ask Claude to map the codebase. Then ask for a plan. Only then let it edit or run commands. This one habit eliminates most “random edits to the wrong files” problems. The impulse to jump straight to coding is strong, but exploration first is always faster.

5. Use subagents to isolate context

The leaked source showed a modular multi-agent architecture with separate system prompts and cache boundaries for each subagent type. The Explore agent is read-only. It can search and analyze but cannot mutate anything. Each subagent runs in its own context window with restricted tool access.

Context contamination is one of the main failure modes in long agentic sessions. Research, planning, and editing have different context needs. Mixing them degrades all three. Use separate agents or modes for each phase. If you are building your own agents, treat context isolation as a design decision, not a side effect.

6. Use worktrees for parallel work

More analysis of the subagent system showed that subagents leverage cached context for fork-join operations, making parallel execution essentially free in terms of repeated context loading. Claude Code spawns background agents in isolated git worktrees, one per unit of work.

When you have multiple independent tasks, use separate worktrees. Do not let several agents edit the same branch. If a task is large, split it into chunks with clear outputs. And stop starting fresh sessions for everything. Continue sessions when working on related code.

7. Configure permissions at the tool level

One of the most concrete findings was the tool count: Claude Code runs fewer than 20 default tools. AgentTool, BashTool, FileReadTool, FileEditTool, FileWriteTool, WebFetchTool, WebSearchTool, and a handful of others. A deeper inventory showed the system can expand to 60+, but the default set is deliberately small. Fewer tools, better results.

8. Reduce approval fatigue

The leaked source confirmed that Claude Code users approve 93% of permission prompts. The auto-mode classifier found in the code is Anthropic’s answer: a layered system that auto-approves low-risk actions while keeping a safety classifier for anything dangerous.

When you approve almost everything, the permission system becomes a speed bump, not a safety mechanism. You stop reading what you approve. Move repetitive safe actions into allow rules. Use Plan mode or Accept Edits mode where appropriate. Use Auto mode when the task is bounded and the direction is clear. The goal is not fewer safety checks. It is better-placed checks you actually pay attention to.

9. Use hooks for repeatable automation

The community found 25+ event-driven hook points in the leaked code, including PreToolUse, PostToolUse, SessionStart, CwdChanged, and more. Hooks are one of the most powerful features in Claude Code and probably the most underused.

A hook that runs tests after every file edit:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "FileEditTool",
        "command": "npm test --silent 2>&1 | tail -5"
      }
    ]
  }
}

The general principle: if you repeat the same instruction in every prompt, it should be a hook.

10. The harness matters more than the prompt

This is the lesson: Sebastian Raschka put it well: Claude Code’s secret sauce is probably not the model. If you are building your own agent, spend less time polishing one giant system prompt. Spend more time on tool boundaries, context loading, review loops, and memory discipline. The best coding agent is not the one with the cleverest instructions. It is the one with the best workflow design.

Bonus: the small details

The leak also surfaced things that are not actionable but say a lot about how the product is built. Wes Bos found 187 hardcoded spinner verbs, the loading messages you see while Claude thinks.

Someone found Boris’s WTF counter, an internal metric tracking unexpected states. Good agent products are not only inference. They are interface, orchestration, trust, and taste.

The bottom line

The takeaway is straightforward: use the product more deliberately: write a better CLAUDE.md, keep memory tight, split exploration from editing, move repeated behavior into hooks, configure permissions properly, and use worktrees when parallelism matters. Most of these features were already documented. It took seeing the internals to realize how seriously the team behind Claude Code takes them.

For anyone building agentic applications, the lesson is the same. The moat is not the model, it is the harness.

• AI-assisted coding moved from autocomplete to agentic code generation.

• That shift made planning a first-class step. Serious teams now start with a spec or a plan before the agent touches the codebase.

• Build split into two paths: full-stack app builders for prompt-to-product flows, and local developer agents for working inside real repos.

• The biggest new category is local developer agents, especially CLI-native ones.

• Async cloud agents are still early, but they point to a delegated model where coding work runs in the background or overnight.

• AI-assisted review is becoming the only practical way to keep up with the volume of AI-generated code.

I wrote about this landscape last year in AI Coding Assistants Landscape (03/2025). The picture is simpler now. The big change is not only that the tools got better. The workflow changed. Not long ago, the center of the story was autocomplete and inline suggestions. In 2026, the center is agentic code generation guided by a plan, followed by stronger review before code ships.

This is an opinionated map of how the market is organizing itself. The easiest way to understand the ecosystem now is through a simple sequence: plan the work, build it with agents, then review what they produced.

1. Plan

The first major shift is that planning stopped being optional. Teams learned the same lesson from multiple directions: if the plan is weak, the build drifts, the review catches more noise than signal, and the whole agent loop becomes harder to trust.

This planning layer now shows up in two forms. There are dedicated spec-driven tools that formalize planning as a standalone practice, and there are build tools that pulled planning into their core workflow.

1A. Dedicated planning and spec-driven systems

Spec-driven development is the clearest expression of this change. These tools turn vague prompts into requirements, acceptance criteria, design notes, and implementation tasks before code generation begins. If vibe coding is “start building and see what happens,” spec-driven development is the counterweight: decide what you are building first, then let the agent execute.

• Kiro, a productized example of spec-driven development that turns prompts into structured requirements, design artifacts, and task plans.

• GitHub Spec Kit, GitHub’s open source toolkit for spec-first workflows and implementation planning.

• OpenSpec, a lighter open source framework for writing reusable specs for coding agents.

Beyond coding-specific spec tools, broader frameworks such as BMAD-METHOD show that structured AI-assisted planning is also expanding into higher-level delivery and agile workflows. The pattern is the same: teams that invest more in upstream intent get more predictable downstream results.

2B. Planning modes inside build agents

Planning is not confined to dedicated planning tools anymore. The stronger signal is that serious build tools now expose ask, plan, explore, or read-only modes before they touch the codebase. That is the clearest sign that planning became part of the agent loop itself, not something attached later.

• Claude Code, exposes Plan Mode for safe code analysis before editing.

• Cursor, uses Ask mode for exploration, questions, and planning before execution.

• Windsurf, treats planning as a built-in part of the Cascade workflow.

• Cline, makes the split explicit with a Plan and Act workflow.

• Codex, separates Ask mode from Code mode.

• Junie, uses Ask mode to collaborate on an action plan before making changes.

One related shift worth noting is that planning is no longer only text. Screenshots, Figma files, and mockups are increasingly becoming structured inputs into the coding workflow. I would not treat that as a separate category yet, but it matters as a bridge from planning into building. v0 screenshots and files is one obvious example, and the broader full-stack app builders category is also moving in this direction by making design artifacts directly usable for PMs, designers, and non-technical builders.

2. Build

This is where the market split most visibly. It is no longer useful to talk about “AI coding tools” as one bucket. Build is now best understood through three practical categories: full-stack app builders, local developer agents, and async cloud coding agents.

The most important change for developers is that local developer agents became the default serious workflow. But before getting there, it is worth separating them from the other branch: full-stack app builders.

2A. Full-stack app builders

This is the category where vibe coding became productized. These tools combine generation, iteration, preview, runtime, and deployment in one surface. They are not just code generators. They are prompt-to-product environments, closer to “build me the product” than “work with me inside my repo.”

This category matters because it serves a broader audience than professional developers: founders, PMs, designers, mixed-role teams, and non-technical builders. It is the closest thing we have to software creation for everyone, and it is expanding the definition of who can build software in a meaningful way.

• Lovable, full-stack app builder aimed at turning prompts into working products quickly.

• Bolt, browser-based full-stack builder with generation, preview, and deployment in one loop.

• v0, Vercel’s AI full-stack app builder with strong UI, design, and production handoff workflows.

• Replit Agent, browser-native environment that can generate, run, debug, and deploy applications.

• Bubble AI, AI-assisted visual app builder closer to no-code product creation than to local repo development.

2B. Local developer agents

This is the biggest change in the market. The story is no longer “which autocomplete tool is best?” It is “which agent loop do you want to build your workflow around?”

Claude Code helped make this category mainstream, especially on the terminal-native side. But the larger shift is broader than any single tool. The strongest open source and commercial energy now clusters around local agents that can plan, edit, run commands, inspect outputs, and iterate, all inside a real development environment, with the developer supervising the loop. This is where professional software engineering lives in 2026.

CLI-native developer agents

Terminal-based development is now a category in its own right. This is the branch where agentic coding feels most explicit and most professional. It keeps the repo, the terminal, the test loop, and the engineering workflow at the center, rather than wrapping them behind a simplified interface. Not long ago, terminal-native agents were a niche. Today, some of the fastest-growing open source projects in the AI-assisted coding space are terminal-first.

• Claude Code, the terminal-native coding agent that made the category mainstream.

• Codex, OpenAI’s local coding agent that also extends into cloud delegation.

• Gemini CLI, Google’s open source terminal agent with strong community adoption.

• OpenCode, a fast-growing open source coding agent with built-in plan and build agents.

• Goose, open source local agent for install, execute, edit, and test loops.

• Aider, Git-first terminal coding assistant that remains highly popular with working developers.

• Amp, Sourcegraph’s terminal agent with deep code intelligence and codebase-wide context.

• Plandex, a terminal agent designed for larger tasks, planning, and sandboxed diffs.

IDE-native developer agents

The IDE-native tools matter just as much, but their mental model changed too. Even in IDEs, the direction moved away from inline completion and toward planning, tool use, command execution, multi-file edits, and local review. The IDE is still the surface, but the agent loop is now the core interaction, not the autocomplete dropdown.

• Cursor, the bridge product from AI-native IDE to full local agent workflow.

• Windsurf, an IDE-native agent centered on planning, editing, execution, and verification.

• Roo Code, a popular open source editor agent with architect, ask, code, and debug modes.

• Cline, an open source IDE agent with a clear plan-then-act workflow.

• Augment, a context-heavy developer agent that also stretches into review.

• Junie, JetBrains-native coding agent for planning and implementation inside the existing IDE workflow.

2C. Async cloud coding agents

This is the delegated branch of the build step. If local agents are “pair with me,” cloud agents are “go do this and come back.” These tools run in remote sandboxes, often triggered from issues or pull request workflows, and return with patches, branches, or pull requests.

This category is smaller than local agents today, but the workflow matters. It is the beginning of a mode where you hand work to an agent from GitHub, or at the end of the day, and let it run while you are doing something else or simply sleeping. That is why I expect this category to grow even if it still feels early.

• Devin, the flagship async remote coding agent for delegated engineering work.

• Codex cloud, OpenAI’s sandboxed remote execution model for delegated coding tasks.

• GitHub Copilot coding agent, GitHub-native delegation from issues and pull request workflows.

• OpenHands, the open source alternative for issue-to-patch and cloud-agent workflows.

• SWE-agent, an influential open source issue-to-patch system that bridges research and practice.

If you want to go deeper on the delegated, async side of this market, this background agents landscape is worth reviewing. It offers a curated map of tools and infrastructure layers behind these workflows.

3. Review

Once agents started writing much more code, review became the new bottleneck. The point of this step is simple: keep the speed of AI code generation without letting quality collapse.

Code generation accelerated faster than our ability to inspect the output manually. That gap is what pulled review into its own category. The strongest part of this layer today is code review. Testing and verification are still lighter, but they are growing quickly as browser-based agents and cloud runtimes become more capable.

3A. Review agents

The most interesting shift in review is timing. AI review is no longer only something that happens after a pull request exists. The stronger tools now review code locally, before commit or before the PR is opened, and then review again once the PR is live.

That creates a two-stage loop: local review first, shared PR review second. It is one of the clearest signs that review is becoming part of the development loop itself and not only a separate final gate.

• Qodo, is built for enterprise-scale review, using dedicated agents, codebase context, PR history, and team rules to review changes before they reach the PR and again at review time.

• CodeRabbit, an AI reviewer that now spans pull requests, IDE reviews, and CLI reviews before commit.

• GitHub Copilot code review, GitHub-native review in pull requests, now complemented by local review in supported tools.

• Augment Code Review, a PR reviewer that routes findings back into the IDE or CLI for fixing.

• Cursor Bugbot, a mostly PR-native automated reviewer focused on catching real bugs with low noise.

• Greptile, a context-aware reviewer focused on repo-wide reasoning over pull requests.

• Graphite Agent, an AI reviewer integrated into Graphite’s stacked pull request workflow.

3B. Testing and verification agents

This is a lighter category than review today, but it is easy to see why it could become much bigger. As browser-based agents, cloud Chromium environments, and agentic end-to-end testing get stronger, more of the validation work that currently lives in manual QA can move into automated review loops.

For now, testing and verification still belong inside the same review step. If review agents inspect diffs, this emerging branch inspects behavior. That distinction will matter more as the code being generated grows in scope and complexity.

• TestSprite, an intent-to-tests workflow that generates, runs, and explains tests.

• Momentic, a browser testing agent focused on end-to-end validation.

• KaneAI, an AI testing agent for browser and workflow automation.

• mabl Agentic Testing, agentic test creation and maintenance for UI flows.

There are also benchmarks starting to emerge around this review layer. Code Review Bench from Martian is worth watching because it treats code review as a useful foundation for measuring code generation quality and validation, combining an offline benchmark with real developer behavior from open source pull requests.

Appendix: enterprise incumbents and platform suites

These tools still matter, especially in enterprise buying conversations, but they are not the sharpest lens for explaining how the market changed:

• Amazon Q Developer, an AWS-integrated developer assistant and terminal agent.

• Gemini Code Assist, Google’s enterprise coding assistant across IDEs and cloud workflows.

• GitLab Duo, GitLab’s integrated AI layer across the software delivery lifecycle.

• Tabnine, a long-running enterprise AI coding assistant focused on controlled deployments.

• watsonx Code Assistant, IBM’s enterprise tool for code generation and modernization.

• TONGYI Lingma, Alibaba’s coding assistant for enterprise and cloud workflows.

• Refact.ai, a self-hostable coding assistant with strong enterprise positioning.

Implications

If this framing is right, a few implications follow for how we work and what we invest in.

→ Planning will increasingly become the starting point, not an afterthought. The best coding tools already start with a plan before generation, and teams that skip this step will find themselves debugging drift rather than building features.

→ Full-stack app builders will keep pulling in design, product, and prototyping workflows. This is expanding who can create software, and that expansion is not slowing down. For product managers, designers, and founders, these tools are becoming the default way to go from idea to working prototype.

→ Local developer agents will keep taking share from autocomplete-first tools because they fit better with how professional developers already work, inside a real repo, with real tests, in a real terminal or IDE. Developers who learn to work effectively with agent loops will have a meaningful advantage over those still treating AI as a smarter autocomplete.

→Async cloud coding agents will grow as delegation becomes more natural. Send work from GitHub or at the end of the day, and let it run in the background. This mode is still early, but it is the beginning of a shift where engineering work does not have to be synchronous.

→ Review is becoming the next bottleneck and the real quality gate in software delivery. As code generation gets better, review will have to become far more sophisticated too. That is where the next major gains in software quality will come from.

→ Testing is still earlier than review, but it is the clearest next expansion area for agentic tooling. As browser-based testing agents improve and cloud runtimes become cheaper, this is where confidence will grow fastest.

My takeaway: AI-assisted coding is no longer one tool category. It is becoming a connected workflow from planning, to building, to gaining confidence in the result. Teams that understand these layers will be better positioned to adopt the right tools at each step. I share similar analysis on X: https://x.com/bibryam and in this newsletter.

The Generative Programmer

A developer-focused digest revealing how generative AI is transforming coding, architecture, and product development.

By Bilgin Ibryam

Here is a high-level summary of how Kubernetes patterns apply to LLM workloads, which Roland and I will cover in more detail in our upcoming KubeCon + CloudNativeCon Europe 2026 talk in Amsterdam.

Same Kubernetes, Different Workload

A typical cloud-native application on Kubernetes follows a well-known stack.

• An Ingress routes HTTP traffic to stateless App Pods managed by a Deployment.

• An init container runs database migrations before the app starts.

• PostgreSQL runs as a StatefulSet with persistent storage.

• A CronJob generates reports on a schedule.

• A layer of DaemonSets, such as Prometheus Node Exporter and Fluentd, provides

That is six Kubernetes patterns at work: Controller, Stateless Service, Init Container, Stateful Service, Batch Job, Daemon Service.

An LLM workload uses the same patterns, but is a fundamentally different kind of workload.

• A model is not an application binary. It is tens to hundreds of gigabytes of learned parameters, read-only data that must be loaded into GPU memory before a server can handle a single request. Meta’s Llama 70B weighs around 140 GB in full precision (FP16), or 35–40 GB with 4-bit quantization. Loading takes minutes, not seconds.

• It requires specific hardware: a node with the right GPU, enough VRAM (Video RAM, the memory on the GPU where weights and intermediate computations live), and sometimes a specific GPU interconnect topology.

• Initialization looks different too. In a traditional app, an init container fetches a config file or runs a migration, a few megabytes, done in seconds. In an LLM stack, the equivalent step stages tens to hundreds of gigabytes of model weights. Once the weights are in place, the model server (vLLM, TGI) goes through a multi-phase startup: loading weights into GPU VRAM, compiling CUDA graphs, and pre-allocating the KV cache (the memory region where the model stores computed attention states so it doesn’t recompute them for every new token). This takes minutes. Your startup probe needs failureThreshold: 60 with periodSeconds: 10, a 10-minute budget.

• The request profile differs too. In a traditional web service, requests have roughly uniform cost. Round-robin load balancing works. LLM inference breaks this assumption: a 10-token request completes in 200 ms while a 4,000-token request occupies a GPU for 30 seconds. Both arrive as identical POST /v1/chat/completions requests. Round-robin creates hot spots.

• Scaling signals break down. Out-of-the-box HPA on CPU is not a good fit for GPU inference workloads. You need scaling on LLM-specific metrics: token queue depth (vllm:num_requests_waiting), time-to-first-token, KV cache utilization.

• Scale-to-zero is impractical when model loading takes five minutes.

• The infrastructure layer changes. Where you had Node Exporter and Fluentd, you now run NFD (Node Feature Discovery) to label hardware, GFD (GPU Feature Discovery) to add GPU model and VRAM labels, the NVIDIA device plugin to expose nvidia.com/gpu as a schedulable resource, and the DCGM exporter (Data Center GPU Manager) to feed GPU metrics to Prometheus. That is your new stack of DaemonSets forming the GPU infrastructure layer.

Projects like KServe (incubating at CNCF) address these by applying the Controller pattern to model serving. You write an InferenceService CRD, declare the model, the runtime, the scaling policy, and KServe reconciles: Deployment, Service, storage initializer, startup probes, GPU scheduling.

Despite all this, the fundamentals are the same. Controller, Stateless Service, Init Container, Stateful Service, Batch Job, Daemon Service, all present. The parameters changed, but the patterns held.

What stays the same in GenAI on Kubernetes

Many Kubernetes patterns apply to LLM workloads without fundamental modification. The pattern works as-is, you only point it at a different workload.

These are the direct mappings. The Kubernetes primitive stays the same, but the workload behind it changes from web apps and databases to model servers, vector databases, and GPU infrastructure.

What changes in GenAI on Kubernetes

These patterns still apply to GenAI, but something fundamental changes about how they work. The pattern skeleton is the same; the parameters, scale, or semantics push them beyond their original design.

This is where LLM workloads start to stretch familiar Kubernetes patterns. The abstraction still holds, but the operational reality changes. Seconds become minutes. Megabytes become gigabytes. CPU-centric assumptions stop working.

Emerging Patterns for AI Workloads

Some patterns do not have clear ancestors in the Kubernetes pattern catalogue. They emerge from the specific characteristics of LLM workloads.

• Model Data Staging addresses the challenge of delivering hundreds of gigabytes of model weights to Pods without turning every scale-up into a multi-minute outage.

• Token-Aware Routing replaces round-robin with metric-driven endpoint selection based on queue depth and KV cache state. This is being implemented through the Gateway API Inference Extension and projects like llm-d.

• RAG Composition wires together four distinct workload types into a coherent application: the orchestrator, the LLM, the vector database, and the ingestion pipeline. Each maps to its natural Kubernetes primitive.

• Disaggregated Serving separates the compute-intensive prefill phase from the memory-intensive decode phase, runs them on different hardware, and lets them scale independently. Projects like llm-d are enabling this model.

• Agentic Workflows introduce LLM agents that plan, use tools, and iterate. They are also driving new protocols such as MCP (Model Context Protocol) for agent-to-tool integration and A2A (Agent-to-Agent Protocol) for inter-agent communication.

  

  Something related: Our friends at Deep Engineering are hosting a workshop, Building MCP Servers in Production, with Peder Holdgaard Pedersen. If you are exploring MCP beyond demos and into real production systems, this is worth a look, register here.

These patterns are covered in depth in Roland and Daniele’s book Generative AI on Kubernetes. Roland and I will be walking through three of them: Model Data Staging, Token-Aware Routing, and RAG Composition at KubeCon Amsterdam this week.

Subscribe now

If you’d like more posts like this on Kubernetes, cloud-native patterns, and how they intersect with AI workloads, subscribe to my newsletter.

👉 If you’re building with LLMs, agents, or generative AI, bookmark this. It’s a living list.

📚 Books

There are many books on AI, but these go deep and explain how prompting actually works in real systems.

• Prompt Engineering for LLMs – O’Reilly, John Berryman, Albert Ziegler

• Prompt Engineering for Generative AI – O’Reilly, James Phoenix, Mike Taylor

• Generative AI Design Patterns – O’Reilly, Valliappa Lakshmanan, Hannes Hapke

• Prompt Design Patterns – Yi Zhou

• Unlocking Secrets of Prompt Engineering – Packt, Gilbert Mizrahi

• LLM Design Patterns – Packt, Ken Huang

• Patterns of Application Development Using AI – Leanpub, Obie Fernandez

🎓 Courses

Most popular learning paths from beginner to advanced prompt engineering.

• Learn Prompting – LearnPrompting

• Advanced Prompt Engineering for LLMs – Elvis Saravia (DAIR.AI)

• Prompt Engineering for Everybody – Udemy

• Anthropic’s Prompt Engineering Interactive Tutorial -Anthropic

🎥 Videos

Overview, discussions, workshops, and real-world explanations of prompt engineering.

• Prompting 101 | Code w/ Claude – Anthropic

• State-Of-The-Art Prompting for AI Agents – Y Combinator

• Building with Anthropic Claude: Prompt Workshop – AI Engineer

• Prompt Engineering Tutorial – Master ChatGPT – freeCodeCamp

• Google’s 9 Hour AI Prompt Engineering Course in 20 Minutes – Tina Huang

• Prompt Engineering Workshop – Hamel Husain

• Prompt Engineering – For Optimal LLM Performance – Valentina Alto

• CMU Advanced NLP 2022 (9): Prompting - Graham Neubig

📄 Whitepapers

Research that introduced modern prompting techniques like CoT, ToT, self-consistency, tool use, and reflection.

• The Prompt Report: A Systematic Survey of Prompt Engineering Techniques – Schulhoff et al
  https://arxiv.org/abs/2406.06608

• A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT – Jules White et al
  https://arxiv.org/abs/2302.11382

• A Systematic Survey of Prompt Engineering in Large Language Models – Pranab Sahoo et al
  https://arxiv.org/abs/2402.07927

• Buffer of Thoughts: Thought-Augmented Reasoning with LLMs – Ling Yang et al
  https://arxiv.org/abs/2406.04271

• Lost in the Middle: How Language Models Use Long Contexts – Nelson F. Liu et al
  https://arxiv.org/abs/2307.03172

• Toolformer: Language Models Can Teach Themselves to Use Tools – Timo Schick et al
  https://arxiv.org/abs/2302.04761

• Prompting in the Wild – Mahan Tafreshipour et al
  https://arxiv.org/abs/2412.17298

• PromptSource – Stephen H. Bach et al
  https://arxiv.org/abs/2202.01279

• Repository-Level Prompt Generation for LLMs of Code – Disha Shrivastava et al
  https://arxiv.org/abs/2206.12839

• Conversing with Copilot – Paul Denny et al
  https://arxiv.org/abs/2210.15157

• Tree of Thoughts – Shunyu Yao et al
  https://arxiv.org/abs/2305.10601

• Chain-of-Thought Prompting – Jason Wei et al
  https://arxiv.org/abs/2201.11903

• Reflexion – Noah Shinn et al
  https://arxiv.org/abs/2303.11366

• Reprompting – Weijia Xu et al
  https://arxiv.org/abs/2305.09993

• LLMs Are Human-Level Prompt Engineers – Yongchao Zhou et al
  https://arxiv.org/abs/2211.01910

• Self-Consistency Improves Chain-of-Thought Reasoning – Xuezhi Wang et al
  https://arxiv.org/abs/2203.11171

• Language Models Are Zero-Shot Reasoners – Takeshi Kojima et al
  https://arxiv.org/abs/2205.11916

• Prompt Engineering (Whitepaper) – Lee Boonstra
  https://www.kaggle.com/whitepaper-prompt-engineering

• The DALL·E 2 Prompt Book (PDF) – dallery.gallery
  https://dallery.gallery/wp-content/uploads/2022/07/The-DALL%C2%B7E-2-prompt-book.pdf

🌐 Websites & Roadmaps

Living documentation, continuously updated guides, and structured learning paths.

• Prompt Engineering Guide – Sander Schulhoff
  https://learnprompting.org/docs/introduction

• Prompting Guide AI – DAIR.AI

  https://www.promptingguide.ai/

• Prompt Engineering Overview – Anthropic
  https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/overview

✍️ Articles

Practical write-ups from teams actively shipping LLM-powered systems.

• Prompt Engineering Best Practices - Sarah Chieng
  https://milksandmatcha.notion.site/Prompt-Engineering-Best-Practices-5aab1f04fce246ad9a39d3b69e80ed99

• Lilian Weng Prompt Engineering Guide – Lilian Weng
  https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/

• Anthropic Claude Code Best Practices – Anthropic
  https://www.anthropic.com/engineering/claude-code-best-practices

• OpenAI Best Practices for Prompt Engineering – OpenAI
  https://help.openai.com/en/articles/6654000-best-practices-for-prompt-engineering-with-the-openai-api

• OpenAI Prompt Engineering Guide – OpenAI
  https://platform.openai.com/docs/guides/prompt-engineering

• OpenAI Cookbook Related Resources – OpenAI
  https://cookbook.openai.com/articles/related_resources

• Mistral Prompting Capabilities – Mistral AI
  https://docs.mistral.ai/capabilities/completion/prompting_capabilities

• ParaHelp Prompt Design Blog – ParaHelp
  https://parahelp.com/blog/prompt-design

• OpenAI Techniques to Improve Reliability – OpenAI
  https://cookbook.openai.com/articles/techniques_to_improve_reliability

• OpenAI Guides: Optimizing LLM Accuracy – OpenAI
  https://platform.openai.com/docs/guides/optimizing-llm-accuracy

• Wikipedia: Prompt Engineering – Wikipedia
  https://en.wikipedia.org/wiki/Prompt_engineering

• Automated Prompt Engineering: Hands-On Guide – Towards Data Science
  https://towardsdatascience.com/automated-prompt-engineering-the-definitive-hands-on-guide-1476c8cd3c50/

• Advanced Prompt Engineering (Chain-of-Thought) – Towards Data Science
  https://towardsdatascience.com/advanced-prompt-engineering-chain-of-thought-cot-8d8b090bf699/

• 5 Prompt Engineering Tips for Developers – Slobodan Mehmedovic
  https://slobodan.me/posts/5-prompt-engineering-tips-for-developers/

• Anatomy of a Prompt – Gyorgy Bakocs
  https://www.linkedin.com/pulse/anatomy-prompt-gyorgy-bakocs/

• Gemini 3 Prompt Practices – Phil Schmid
  https://www.philschmid.de/gemini-3-prompt-practices

• Prompt Engineering vs Blind Prompting – Mitchell Hashimoto
  https://mitchellh.com/writing/prompt-engineering-vs-blind-prompting

• Deterministic Quoting – Matty Yeung
  https://mattyyeung.github.io/deterministic-quoting

• Rewrite Your Prompts – Max Leiter
  https://maxleiter.com/blog/rewrite-your-prompts

• Prompt Engineering 101 – Amatria
  https://amatria.in/blog/PromptEngineering

• Prompt Engineering 201 – Amatria
  https://amatria.in/blog/prompt201

• AI Tools Up: Prompt Engineering Resources – aiToolsUp
  https://aitoolsup.com/best-resources-to-become-prompt-engineer/

• Prompt Examples – OpenAI
  https://platform.openai.com/docs/examples

• Prompt Engineering Roadmap – Roadmap.sh
  https://roadmap.sh/prompt-engineering

🧰 GitHub Repositories

Hands-on prompt examples, tooling, collections, and experiments.

• https://github.com/PromptLabs/Prompt-Hacking-Resources

• https://github.com/brexhq/prompt-engineering

• https://github.com/anthropics/prompt-eng-interactive-tutorial

• https://github.com/openai/openai-cookbook

• https://github.com/dair-ai/Prompt-Engineering-Guide

• https://github.com/promptslab/Awesome-Prompt-Engineering

• https://github.com/thunlp/PromptPapers

• https://github.com/thunlp/OpenPrompt

• https://github.com/guidance-ai/guidance

• https://github.com/microsoft/PromptWizard

• https://github.com/swyxio/ai-notes

⚙️ Tools & Services

Playgrounds, prompt testing tools, optimizers, and prompt management platforms.

• OpenAI Chat Playground https://platform.openai.com/chat/edit

• OpenAI Tokenizer https://platform.openai.com/tokenizer

• PromptPerfect https://promptperfect.xyz/

• FlowGPT Guide https://guide.flowgpt.com/

• PromptPort https://promptport.ai/

• Prompt Optimizer https://promptoptimizer.tools/

• TextSynth Completion Playground https://textsynth.com/completion.html

• PromptLayer https://www.promptlayer.com/platform/prompt-management

• Reverse Prompt Engineer https://www.agenticworkers.com/reverse-prompt-engineer

💬 Communities

Where prompt engineers share techniques, failures, and experiments.

• https://www.reddit.com/r/PromptEngineering/

• https://www.reddit.com/r/PromptDesign/

• https://www.reddit.com/r/GenAI4all/

• https://www.reddit.com/r/PromptSharing/

• https://www.reddit.com/r/ChatGPTPromptGenius/

• https://www.reddit.com/r/OpenAI/

Thanks for reading The Generative Programmer 🤖
Subscribe for more curated AI resources, agent patterns, and practical lessons from building with LLMs.

🔥 Top Picks from Issue #17

🔐 How We Hijacked a Claude Skill with an Invisible Sentence - Josh Devon
🧠 Why your AI agents need domain awareness - Russ Miles
🔧 How I Use Every Claude Code Feature - Shrivu Shankar
📊 GenAI in Production: MLOps or GenAIOps? - Dr. Kartakis
👌 The Context Engineering Guide - Weaviate
🔍 Building a Deep Research Agent from scratch - Aurimas Griciūnas
🛡️ Design Patterns for Securing LLM Agents against Prompt Injections - Luca Beurer
📈 I Went All-In on AI. The MIT Study Is Right. - Josh Anderson

🎯 Featured Article

This in-depth tutorial by Aurimas Griciūnas walks you through building a Deep Research Agent from scratch using the open-source DeepSeek R1 model.

It covers every step, from planning and web search to summarization and reflection, without relying on any orchestration frameworks. Highly recommended to check it out!

🤖 Building Agentic Systems

How We Hijacked a Claude Skill with an Invisible Sentence - Josh Devon reveals a critical security vulnerability in Claude Skills that allows attackers to override instructions with invisible text!

Agent IAM in Cloud Native World with SPIFFE and Istio - Mr Posta’s slides on cloud-native identity management with SPIFFE. 🔥

Domain Driven Agent Design - by Russ Miles - Miles explains why AI agents fail when deployed without domain context, creating impressive demos that collapse in production environments.

New prompt injection papers: Agents Rule of Two and The Attacker Moves Second - highlights new research on prompt injection vulnerabilities along with WiFi-enabled conference badge hacking and other tech links.

Design Patterns for Securing LLM Agents against Prompt Injections - Luca Beurer’s paper on security framework for LLM agent protection.

How Many Tools Functions Can An AI Agent Have - to do

💫 The Context Engineering Guide - Learn to optimize LLM performance through context engineering patterns that overcome hallucinations and build reliable AI applications with real-world context.

Why Model Context Protocol and Agentic Workflows Are Shaking Up How We Build Apps - Monica Hockelberg explains how MCP and agentic workflows transform rigid development into more fluid, adaptable systems for the AI era.

Bulletproof agents with the durable task extension for Microsoft Agent Framework - New extension enables resilient agent workflows that can survive interruptions and automatically resume processing.

Agent OS Workflow for Spec-Driven Development - Brian Casel proposes a six-phase AI agent workflow for spec-driven development.

The complete guide to LLM observability for 2026 - Ghost explains how to implement comprehensive LLM monitoring systems with frameworks for tracing, guardrails, cost management, and governance.

Context Engineering in Manus - Erik explores how Manus handles context management for AI agents, addressing challenges of context windows filling up during extended tool-calling sessions.

Building a Toolformer model with OpenAI and Remix - Josh Sanger shows how to build a weather assistant using Toolformer, enabling AI to use external tools via API calls.

Making Agent-to-Agent (A2A) Secure and Reliable with Dapr - I tried A2A with Dapr and saw how easily it adds mTLS, policy enforcement, tracing, and self-healing behavior to any agent workflow. Then showed step-by-step how to turn a deterministic workflow into an agentic one.

🚀 Choose a design pattern for your agentic AI system - Google’s guidance for selecting appropriate agent design patterns to build AI systems that can handle autonomous decision-making and complex workflows.

MCP Apps: Extending servers with interactive user interfaces - Ido Salomon introduces a new extension enabling MCP servers to deliver interactive UIs to hosts, addressing a top community request.

💻 Coding with AI

How I Use Every Claude Code Feature - Shrivu Shankar shares detailed insights on leveraging Claude Code for both hobbyist projects and professional development with high-volume token usage.

Claude Code Can Debug Low-level Cryptography - Filippo Valsorda describes how Claude Code successfully identified a complex bug in his post-quantum signature algorithm implementation when he was stuck.

The evolution of code review practices in the world of AI - Alex Pliutau examines how AI tools are transforming code reviews, improving efficiency while maintaining human oversight.

🔥 GitHub - github/awesome-copilot - github - Curated toolkit to supercharge Copilot.

🔥 GitHub - hesreallyhim/awesome-claude-code - Community-curated collection of commands, files, and workflows to enhance productivity with Anthropic’s CLI-based coding assistant.

How I use AI (Oct 2025) - Stolovitz reflects on his AI usage as a software engineer, highlighting Copilot’s impact on coding productivity since its early days.

Rulebook-AI wants to “elevate vibe coding to vibe engineering” - Tool transforms AI coding assistant configurations into structured guidance, eliminating fragmentation and inconsistency in development workflows.

📰 Long-Form Reads

A Survey of Context Engineering for Large Language Models - Lingrui Mei’s comprehensive overview of techniques to optimize LLM context usage, from retrieval methods to context compression.

The State of AI - McKinsey’s report on current AI adoption trends, business impact, and implementation challenges across industries.

🔬 I Went All-In on AI. The MIT Study Is Right. - Josh Anderson shares firsthand experience using Claude Code exclusively for three months to understand why 95% of corporate AI initiatives fail.

GenAI in Production: MLOps or GenAIOps? - Dr. Kartakis analyzes various operational frameworks for deploying GenAI solutions, clarifying differences between MLOps, LLMOps, and other emerging approaches.

What would you do if you had a chance to sneak peak in the year 2030 and you were a Hubber? - A developer’s 2025 forecast of AI’s rapid takeover of coding jobs, driven by economics and efficiency gains across most software domains.

The Death of Software Engineering as a Profession - Jason Scheirer reflects on incorrect predictions about programming careers and how specialized knowledge remains valuable despite technological advances.

🎨 Nano Banana can be prompt engineered for extremely nuanced AI image generation - Max Woolf explores how Nano Banana offers sophisticated image generation amid competition from FLUX.1-dev, Seedream, and ChatGPT’s viral features.

🎙️ YouTube & Podcasts

The Secrets of Claude Code From the Engineers Who Built It - Explains how Claude Code enables developers to ship features in unfamiliar codebases more efficiently, with each new feature making subsequent development easier.

Practical AI - Podcast making AI accessible through real-world applications.

🗞️ News and Updates

Akshay on X - Who is a Full-stack AI Engineer?

Paweł Huryn on X - 10 Principles of Building AI Agents:

Paweł Huryn on X - Context engineering is the new prompt engineering.

Aurimas on X - AI Engineering Learning Roadmap

TOON (Token-Oriented Object Notation) - Aurimas Griciūnas briefly explains how TOON increases model accuracy while reducing token count, critical for optimizing agentic systems.

🛠️ Tech & Tools

llmtext - Turn any llms.txt into a dedicated MCP server

GitHub - agentregistry-dev/agentregistry - Centralized registry for AI artifact governance.

AI Connectors Directory - Directory of Remote MCP servers for AI custom connectors.

DeepCode: Open Agentic Coding - Open-source tool offering terminal-based and web interfaces for AI-powered code generation from papers and text.

Prompt-Hacking-Resources - PromptLabs’ curated collection of resources for AI red teaming, jailbreaking, and prompt injection, designed for those interested in AI/ML security and safety.

OpenCode | The open source AI coding agent - A privacy-focused AI coding assistant offering free models with no account required and integrations across multiple platforms.

GitHub - toon-format/toon: 🎒 Token-Oriented Object Notation (TOON) - A compact JSON alternative optimized for LLMs that combines YAML’s indentation structure with CSV-like layouts for efficient token usage while maintaining readability.

GitHub - Portkey-AI/gateway - Open-source AI gateway providing fast routing to 1600+ language, vision, audio, and image models with integrated guardrails and enterprise-ready security.

GitHub - metatool-ai/metamcp - MCP proxy that aggregates multiple MCP servers into a unified endpoint with middleware support, enabling developers to build agents on this infrastructure.

You’re Burning 0.02 Per 1K JSON Tokens You Don’t Need To - Ankita Tripathi explains how to optimize JSON structures in API calls to reduce token usage and lower costs when working with AI models.

💰 Frugal AI - Intelligent Application Cost Engineering - AI-powered tool that optimizes application code across major cloud platforms by automatically identifying and fixing inefficiencies in code rather than just resizing infrastructure.

Technology Radar - Thoughtworks’ biannual guide tracking emerging tools, techniques, and frameworks is AI-dominated.

17 Top MCP Registries and Directories - Comprehensive guide to the best MCP registries for server discovery.

cto.new - Free AI code agent offering access to frontier models from Anthropic and OpenAI without requiring credit cards or API keys.

Claude Skills Marketplace - Directory for browsing, searching and installing Claude skills from GitHub, including official Anthropic skills, code skills, and AI automation workflows.

GitHub - anthropics/skills - Anthropics’ repository of reusable Claude skills that enable specialized tasks across creative, technical, and enterprise workflows with clear documentation.

GitHub - langwatch/better-agents - CLI tool and standards that enhance coding assistants to build production-ready agents with industry best practices.

GitHub - ruvnet/claude-flow - Enterprise-grade AI orchestration platform using swarm intelligence with persistent memory and MCP tools for enhanced development workflows.

Kagenti - Kubernetes-based control plane for AI agents that works with any framework, providing modular components to streamline production deployments.

GitHub - kubernetes-sigs/agent-sandbox - Kubernetes CRD for managing isolated, stateful singleton workloads with stable identity, designed for AI agent runtimes and similar use cases.

⚡Code Wiki - Google’s new Gemini-generated documentation.

📚 Learning Picks

🎓 5-Day AI Agents Intensive Course - A 5-day Google course on Kaggle to build, evaluate, and deploy real-world AI agents.

👍 Google, OpenAI, Anthropic Offer Free AI Guides - Here are ten free AI guides worth bookmarking.

🎭 AI Humor

Share The Generative Programmer

👋 See You Next Time

That wraps this issue. If it helped you, pass it along or subscribe. 🙏

In this post, I’ll share a practical guide on how to make your open source project easier for LLMs to understand, and for humans to use through AI tools.

1. Make Your Project Discoverable by AI

When developers face a problem, or research a topic, they don’t go any longer to Stack Overflow or Google first — they ask an LLM through ChatGPT, Claude, or a similar service. Questions such as “How to tune Kafka for low-latency?” or “What’s the best open-source MCP implementation for Kubernetes?” are now answered directly by LLMs.

When a developer is in the zone within their IDE and faces a common issue, like a Python dependency error: “cannot import module x”, they ask their AI assistant inside the IDE how to fix it.

Modern AI systems combine their training data with live web search, scanning documentation, repos, and blogs to generate the best up-to-date responses. But most project sites are designed for people, not machines, they are full of menus, ads, and nested pages. Critical details like installation flags, version notes, or API parameters are often buried deep and hard for AI crawlers to find. As a result, your project may be misunderstood or overlooked even if it’s well-known.

Using llms.txt to Help AI Find the Right Docs

llms.txt is a simple Markdown file placed at the root of your project’s site that gives AI models a clean, structured map of your most relevant documentation. Think of it as a robots.txt for language models, but instead of blocking crawlers, it guides them to the right content. It lists a short summary, key links (docs, APIs, SDKs, examples), and optional secondary sections.

Add /llms.txt to the root of the project website, keep it updated alongside your docs, and every AI-powered search or assistant will instantly understand what your project is and where to look next. The file makes your project easier to find, quote, and recommend in AI-driven tools like ChatGPT, Copilot, and Sourcegraph. There are hundreds of websites already using with it: Supabase, DuckDB, Turso, Hugging Face, Langfuse, and many more in various directories.

llms.txt is an easy addition that can give visibility to your project in a world where LLMs are becoming the primary way of discovering and consuming information. As shown by the tracking site llmstxt.ryanhoward.dev, it’s not yet widely adopted, but the fact that Anthropic themselves use llms.txt and recommend it as part of agentic documentation is a strong signal that it’s the right direction to follow.

There are plenty of tools and plugins that can help you create and validate these files easily, such as llms_txt2ctx, vitepress-plugin-llms, and docusaurus-plugin-llms. To learn, check out llmstxt.org.

2. Onboard AI Agents to Your Project

Open source projects today communicate their community policies and expectations through a variety of simple text files, for example, README.md, INSTALL.md, CONTRIBUTING.md, CODE_OF_CONDUCT.md, DEVELOPMENT.md, and ISSUE_TEMPLATE.md. These files explain how to set up the project, contribute, follow coding guidelines, or report issues. This structure has worked well for years when humans were the primary readers.

In the meantime, the number of developers using AI‑enabled IDEs and CLI tools is growing rapidly. Millions of developers rely on Cursor (now surpassing a million users), Claude Code CLI, and OpenAI Codex daily. Yet these users are underserved, their IDEs can’t easily interpret the project’s policies, build steps, contribution rules and community best practices. As a result, contributing through AI‑assisted tools often leads to manual onboarding, lower‑quality pull requests, and contributor-maintainer tension.

Teaching Coding Assistants Your Project’s Way of Working

This is where agent context files come in. The idea started with different IDEs introducing more advanced ways of sharing project context — for example, .cursor/rules files in Cursor, which began as simple rules and later evolved into structured folder hierarchies, or CLAUDE.md, used by Claude CLI to encode build and contribution instructions. These formats help AI-enabled tools understand how to build, test, and navigate a codebase.

As the space grew fragmented with various formats, AGENTS.md led by OpenAI began to emerge as the most widely adopted standard for defining project context. Today, it’s becoming the common denominator across AI-assisted environments, with over 30,000 pull requests on GitHub contributing AGENTS.md files in open-source projects.

AGENTS.md files act as a README for AI agents. They summarize how to build, test, and contribute to your project, covering environment setup, dependency installation, code style, test execution, and commit message rules — but in a way that AI tools can parse and follow. Supported by major IDEs and CLI tools such as Cursor, VS Code, GitHub Copilot, Aider, RooCode, Gemini CLI, Jules, Factory, and Devin, these files help AI agents understand your project’s structure and workflow.

With these files, AI assistants can follow project conventions, and produce contributions that align with human developers’ expectations, reducing friction in collaborative development.

These files are often paired with AI-assisted development guides that show contributors how to configure their IDEs and CLIs for the best experience — such as Angular’s AI development guide and Convex’s guide for Cursor.

In short, AGENTS.md and accompanying IDE setup guides provide the missing layer of context between your code and the growing ecosystem of AI-powered development tools. It’s a lightweight addition that helps AI understand your project’s workflow — and makes your repository ready for the era of AI-assisted coding.

In short, AGENTS.md and accompanying IDE setup guides provide the missing layer of context between your code and the growing ecosystem of AI-powered development tools. It’s not just about onboarding developers anymore — it’s also about onboarding AI agents. This file acts as an onboarding guide for agents, helping them understand your project’s structure, style, and expectations, so they can contribute effectively and make every developer more productive from day one.

3. Define Your AI Contribution Policy

AI coding tools are now part of everyday development, but most open‑source projects still lack clear policies on how and when they can be used. Without guidance, contributors interpret “acceptable AI use” differently, leading to inconsistent pull requests, hidden AI‑generated code, and extra work for maintainers who must assess both quality and authenticity.

Setting Ground Rules for AI‑Assisted Contributions

Projects like Ghostty, Gramps, Servo, and Scientific Python illustrate different approaches, from allowing AI with disclosure, to banning it outright. These examples show that there’s no universal answer, but various efforts to help avoid tension and maintain trust. A great reference comes from the Open Infrastructure Foundation’s policy on AI‑generated content:

“As a contributor, you are responsible for the code you submit, whether you use AI tools or write it yourself. Some AI tools offer settings, features, or modes that can help, but these are no substitute for your own review of code quality, correctness, style, security, and licensing.”

It’s worth emphasizing that every pull request is still reviewed and maintained by humans, not machines. Contributors must ensure that AI‑assisted code meets the same quality, readability, and consistency expectations as any manually written code.

There’s also a broader movement around structured, transparent AI collaboration, such as the Vibe Coding Manifesto. It advocates for integrating AI into open source responsibly, not rejecting it, but managing it through clear PR rules, contributor transparency, and supporting documents like PROMPTING.md. The manifesto also outlines practical steps such as creating small, focused PRs, running self‑reviews and tests before submission, adding clear AI attributions, and limiting concurrent PRs to avoid “PR spam.” These concrete recommendations help maintain quality while keeping the review workload manageable.

Explicit AI contribution guidelines help maintain a healthy balance between speed and quality. Whether your project allows, restricts, or just tracks AI use, defining the rules early prevents confusion and keeps your contributor community aligned.

4. Scale Code Reviews with AI

Once your project becomes more discoverable and contributor‑friendly with clear guidelines, agents onboarded, you’ll start seeing more AI-assisted activity and more pull requests. Reviewing those PRs becomes one of the primary jobs of maintainers. Some PRs might come from bots or low‑quality AI output and can be easily rejected, but many will vary significantly in quality and completeness. The only scalable way to keep up with this volume of AI‑assisted contributions and maintain quality is to use AI for reviewing, too!

Bringing AI into the Review Process

AI can perform first‑pass reviews, freeing human maintainers to focus on architecture, design, and logic rather than repetitive or stylistic feedback. Such tools act as automated reviewers that integrate directly with GitHub. They can:

• Issue Triage & Labeling – Categorize issues automatically

• Documentation Sync – Ensure code and docs remain aligned

• External Contributor Reviews – Apply stricter checks for new contributors

• Custom Review Checklists – Enforce team standards and consistency

• Path‑Specific Reviews – Trigger deeper analysis on critical file changes

• Scheduled Maintenance – Automate repository health checks

• Security‑Focused Reviews – Detect vulnerabilities with OWASP‑aligned checks

Among the most popular AI tools for code reviews are:

• CodeRabbit – the most widely adopted open‑source‑friendly AI code review tool.

  

  CodeRabbit integrates directly with GitHub and offers free plans for open‑source projects. It supports both IDE‑based inline reviews and PR‑based multi‑file reviews, giving teams flexibility for internal and external contributions. Its context‑aware reviews understand file dependencies and coding patterns, and it can review uncommitted changes directly in the IDE before a PR is even created, reducing friction and catching issues early.

• Claude Code Action – integrates Anthropic’s Claude for PR review and comment generation, providing natural‑language insights and feedback.

• OpenAI Codex Cloud Review – runs as a GitHub Action to automate AI‑based feedback on pull requests and highlight potential issues.

As AI assistants generate more code, the number of incoming PRs will rise. Having AI review these PRs first ensures consistent quality without overloading maintainers. The workflow becomes: AI writes → AI reviews → humans approve. That loop keeps velocity high while maintaining the standards as expected.

5. Make Your APIs Agent-Ready

If your project already exposes an API, CLI, or has a client SDK, it’s time to think about how AI agents can interact with it directly. Developers are no longer the only consumers of APIs, AI assistants are becoming first‑class users, too. Yet most APIs today are not agent‑ready: assistants can read about them but not interact in a structured, safe way.

Opening Your APIs to AI Agents with MCP

The Model Context Protocol (MCP) is an emerging open standard that lets AI agents connect to tools, APIs, and data sources. Exposing your API or CLI via MCP makes your project agent‑ready, enabling AI systems to query, test, and trigger actions contextually instead of copy‑pasting examples. It improves discoverability, automation, and supports AI‑native workflows where agents use your project the same way as developers do. It also connects your project to the growing MCP ecosystem of compatible tools, browsers, and registries.

Projects like Apache Kafka, Turso, DuckDB, and Redis are early examples of being agent‑ready. Some already expose MCP endpoints that let assistants query data or perform operations directly. Cloud services such as Confluent Cloud, Supabase have gone further, hosting full MCP servers that make their APIs seamlessly accessible to AI tools.

To get started, tools like FastMCP can automatically generate MCP servers from any OpenAPI specification, instantly turning your existing API into one that AI models can use through MCP. Over time, you can evolve toward a purpose‑built MCP server. Platforms such as Speakeasy also provide MCP server generators with free plans for open‑source projects, making it easy to experiment.

In short, if your project has an API, offering MCP‑based access is becoming table stakes. Adding MCP support transforms your project from something AI agents can only read about into something they can use directly, unlocking the next phase of open‑source and AI integration.

6. Turn Docs into Conversational Interfaces

Developers don’t have the time to dig through endless documentation pages or wait for answers in Discord. They expect instant help, the same experience they are used to from AI tools. Yet, most open‑source documentation is static and unresponsive to real‑time questions, and even outdated as the code changes faster.

How Conversational Docs Improve Developer Onboarding

Adding an AI‑powered chat interface to your docs lets users ask questions directly, based on your project’s documentation, issues, and source code. Tools like Kapa.ai, Inkeep, CrawlChat can index your site, GitHub repo, or forums and deliver answers instantly inside your website, Slack, or Discord. Such services improve onboarding, reduce repeated support requests, and help users learn faster through natural conversation.

If these tools are not affordable for your project, you can also build a simple in‑house alternative like CrewAI’s “Chat with the Docs”, or index your documentation with Context7 and expose it as an MCP server, allowing users to query your docs directly from their IDE.

This is an evolving space, but it’s likely that in the future, all open‑source projects will have built‑in AI chat interfaces, offered for free, either sponsored by their open‑source foundations or integrated directly into platforms like GitHub. For now, you have to find ways to cover this cost.

7. Automate Community Tasks with AI

As open-source communities grow and AI-assisted development accelerates, maintainers face a constant flow of new issues, PRs, and support questions. Repetitive tasks, triaging, labeling, answering common questions, or closing stale tickets, can consume hours that could be spent improving the project itself.

Let AI Handle the Repetitive Work

AI maintainers like Dosu automate many of these repetitive tasks. They can triage issues, answer contributor questions, close inactive discussions, remind authors about missing documentation, and enforce contribution guidelines — all while keeping conversations active and polite. Dosu already works with major projects like LangChain, Prisma, Strapi, Apache Airflow, and several CNCF initiatives, and is free for open-source use (with CNCF and ASF partnerships in place).

In short, AI maintainers act as 24x7 project maintainers, handling the administrative overhead so human maintainers can focus on technical leadership, community growth, and long-term vision.

AI-Ready Project Checklist for Maintainers

Every open-source project has its own culture, workflows, and pace of change. Yet as AI rapidly reshapes how developers build and collaborate, standing still is the worst option. The right move is to adapt early and use AI as an advantage, not a disruption. This checklist helps maintainers identify where to start.

For Users

1. Make your project discoverable: Create llms.txt listing key docs, APIs, and examples so LLMs can index your project. This is a top-of-funnel lever, but with still-unproven impact; treat it as a follow-on step after the other core items.

2. Turn docs into conversations: Deploy a tool like Kapa.ai trained on your documentation and community resources to answer user questions instantly. This is no longer a luxury: users now expect conversational help, and it significantly improves new user experience.

3. Open your project APIs to agent use: If you have a CLI, SDK, or API, create an MCP server so AI agents can call and use it directly. Comprehensive MCP support makes your project easier to integrate with AI tools and stand out among alternatives.

For Contributors

4. Onboard AI-assisted tools to your project: Add AGENTS.md with build, test, and style instructions so AI tools can quickly figure out how to work with your code. Thousands of projects already use it, making it one of the easiest and highest-impact improvements.

5. Define a clear AI contribution policy: Update CONTRIBUTING.md and PR templates with a reminder that contributors are responsible for submission quality and correctness, regardless of which tools they use. This reinforces human accountability while promoting transparency as AI-assisted contributions grow.

For Maintainers

6. Scale code reviews with AI: Connect CodeRabbit or a similar asynchronous AI bot to automatically review pull requests and provide feedback for free on open-source projects. A small setup effort here pays back quickly by reducing reviewer fatigue and catching early issues.

7. Automate repetitive community tasks: Install Dosu or a similar GitHub bot to triage issues, answer questions, and keep discussions organized. Automation beyond code reviews helps sustain healthy collaboration and saves maintainers valuable time.

Together, these practices ensure your project is set up to benefit from AI at every level: users can discover it, get answers instantly, and use it with their AI tools; contributors have clear onboarding and AI usage guidelines; and maintainers gain automation for reviews and community operations. The space is evolving fast, keep an eye on relevant tools and practices, subscribe, and share how you’re using AI in open source.

🔥 Top Picks from This Issue

🧠 Writing Effective Tools for AI Agents – Anthropic 🔥
🧩 Effective Context Engineering for AI Agents – Anthropic again
🏗️ Building Production-Ready Agentic Systems – Shopify’s lessons
🧬 Deep Agents: From Shallow to Deep... – Elvis Saravia
💻 How to Vibe Code as a Senior Engineer – Alex Maccaw
🚀 The AI-Native Software Engineer – Addy Osmani
🧠 How I’m Using Coding Agents in September 2025 – Jesse Vincent
🧭 Context Engineering Needs Domain Understanding – Rod Johnson
⚡ From GPT-2 to gpt-oss: Architectural Advances – Sebastian Raschka 🔥
💡 You Should Be Rewriting Your Prompts – Max Leiter
🧱 Google’s MCP Toolbox for Databases Is Now Open Source
🔥🔥🔥 Prompting 101 - Hannah & Christian from Anthropic

…and if you dare, 100+ updates to explore 👇

Share

🎯 Featured Article

Writing effective tools for AI agents - Anthropic outlines techniques for creating effective tools for LLM agents using the Model Context Protocol, sharing key principles for writing high-quality tools that bridge deterministic and non-deterministic systems.

📰 Building Agentic Systems

🔥🔥🔥 Effective context engineering for AI agents - Anthropic explains how context engineering is replacing prompt engineering, focusing on optimizing the entire token context to achieve consistent LLM performance rather than just finding the right prompt phrases.

Agentic AI Architecture Framework for Enterprises - InfoQ - A framework for building autonomous AI systems with architectural components and implementation patterns.

🔥 AI Agent Orchestration Patterns - Guide to designing multi-agent systems that handle complex tasks collaboratively by Microsoft.

🔥 Building production-ready agentic systems - Shopify’s journey building a production-ready AI assistant with practical lessons learned.

Equipping agents for the real world with Agent Skills - Anthropic: AgentSkills packages domain expertise for more capable AI assistants.

Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks - Microsoft’s multi-agent system that solves complex tasks through collaborative AI agents.

Supporting our AI overlords: Redesigning data systems to be Agent-first - Berkeley researchers propose redesigning databases for LLM agents’ unique query patterns.

Managing context on the Claude Developer Platform - Anthropic introduces new context management capabilities that help developers build AI agents capable of handling complex, long-running tasks without hitting context limits or losing critical information.

Agent Design Pattern Catalogue: A Collection of Architectural Patterns - Yue Liu - A collection of design patterns for building foundation model agents.

The 5 levels of AI agent autonomy: learning from self-driving cars - Maps coding agents to self-driving car autonomy levels, from manual to fully autonomous.

🔥 Deep Agents - AI systems evolving from shallow to deep agents with strategic planning capabilities.

📰 Coding with AI

🔥🔥🔥 How to Vibe Code as a Senior Engineer - Alex Maccaw explains how “vibe coding” leverages AI models to dramatically accelerate software development, turning traditionally expensive and time-consuming coding processes into rapid, efficient workflows for senior engineers.

Read That F*cking Code! - Developers need to actually read the code that AI generates for them.

🔥 The AI-Native Software Engineer - : Engineers who embrace AI as partners can multiply their productivity.

Onboarding for coding agents - Simplified context delivery for AI coding assistants.

Claude’s new Code Interpreter - reviews Claude’s Code Interpreter and showcases various AI development tools.

AI Coding Assistants for Large Codebases: A Complete Guide - Molisha Shah explains how effective AI coding assistants for large codebases need to understand entire repositories and architectural patterns, not just provide simple autocomplete functionality.

Designing agentic loops - explains how to maximize the potential of coding agents like Claude Code and Codex CLI by designing effective agentic loops that enable these AI tools to iterate toward solutions.

Embracing the parallel coding agent lifestyle - Simon Willison: Developer’s shift toward using multiple AI coding assistants at once.

🔥 How I’m using coding agents in September, 2025 - Developer’s workflow using Claude Code with git worktrees for parallel project management.

Vibe coding is not the same as AI-Assisted engineering. - clarifies the critical distinction between casual “vibe coding” and professional “AI-assisted engineering,” emphasizing that conflating these approaches risks devaluing engineering discipline and misleading newcomers about production software requirements.

Beyond the IDE - explores programming’s evolution from hardware to AI-assisted environments.

Reverse Engineering your Software Architecture with Claude Code to Help Claude Code - Nick Tune: Claude Code works best when it understands your system’s full functionality.

Beyond vibe coding: How AI can transform pull requests - Thoughtworks: Enterprise coding needs more than AI prompts due to regulatory and legacy constraints.

Exploring Cursor, Windsurf and Copilot with GPT-5 - Comparative analysis of GPT-5 coding tools across different development scenarios.

The Rule Maker Pattern: Creating Deterministic Execution with AI Probabilistic Generation - Guy Podjarny explains how developers can establish clear rules and guidelines to transform AI’s unpredictable outputs into reliable, deterministic execution for more consistent results.

How tech companies measure the impact of AI on software development - Orosz: Companies tracking whether AI coding tools justify their increasing costs.

How GPT5 + Codex took over Agentic Coding — ft. Greg Brockman, OpenAI - OpenAI’s GPT-5-Codex disrupts Anthropic’s coding dominance.

📰 Long-Form Reads

🔥🔥🔥 Context Engineering Needs Domain Understanding - Rod Johnson: Context engineering replaces prompt engineering with more precision.

🔥 You should be rewriting your prompts - Max Leiter: Different LLMs require different prompting approaches for best results.

Comparison - LLMs for Creating Software Architecture Diagrams - Testing if AI can create architecture diagrams but not replace architects.

Against “Brain Damage” - debunks fears that AI harms cognition, suggesting productive AI use instead.

GPT-5: Key characteristics, pricing and model card - : Brief notes on OpenAI’s new models and ChatGPT features.

The art and science of context engineering - CodeRabbit examines how effective AI code review tools require sophisticated context engineering to understand specific codebases deeply rather than simply pattern-matching against general rules.

🔥🔥🔥 From GPT-2 to gpt-oss: Analyzing the Architectural Advances - Technical breakdown of OpenAI’s new open-weight models and their architectural improvements.

Superintelligence - Meta’s roadmap for developing safe, advanced AI systems beyond human intelligence.

10 Proven Ways to Get Your Brand Mentioned in AI Answers - Strategies for brand visibility in AI responses through quality content placement.

How far can we push AI autonomy in code generation? - Böckeler: AI can build simple apps but still requires human supervision.

Mastering MCP Server with Spring Boot & AI - Standardized protocol for AI model-application communication.

Prompt injections as far as the eye can see - Researcher documents daily AI prompt injection vulnerabilities across multiple tools.

APIs don’t make good MCP tools - Reilly Wood explains why automatically converting existing APIs into Model Context Protocol tools often works poorly due to context window limitations and the fact that web APIs weren’t designed with these constraints in mind.

Agentic AI has changed my career. I don’t write code… - Elliot Graebert: Manager who stopped coding after early career promotion.

Less is More: Optimizing Function Calling for LLM Execution on Edge Devices - Streamlining LLM function calls for better edge device performance.

Building AI Products In The Probabilistic Era - AI systems work in ways we can’t fully predict or understand.

Your next job will require AI skills - : AI fluency becoming essential across all job functions.

Master the Blueprint: LLM Prompts for Perfect PRDs - Alward shares template for creating LLM-generated PRDs optimized for coding agents.

How AI is Transforming the PRD Process - Sean Shoffstall reflects on how AI tools are revolutionizing product requirements documents, addressing the longstanding problems of traditional PRDs that tend to be either too vague or overly detailed.

Writing product requirements with AI - Kapadia examines why PMs struggle with requirements documentation and AI limitations.

Using LLMs in Software Requirements Specifications: An Empirical Evaluation - Study comparing LLMs to humans in creating software requirement documents.

Vibe Specs: Vibe Coding That Actually Works - Luke Bechtel advocates for making AI write requirements before code, arguing this 5-minute investment saves hours of confusion and improves productivity.

LLM Evaluation: Practical Tips at Booking.com - George Chouliaras shares Booking.com’s methods for evaluating generative AI applications.

To vibe or not to vibe - Birgitta Böckeler examines the nuanced debate around AI-generated code review, challenging binary perspectives and suggesting that the appropriate level of review depends on various contextual factors.

LLMs as Parts of Systems - Marc’s Blog - Systems built with LLMs matter more than LLMs’ theoretical capabilities alone.

Attention Is the New Big-O - Alex Chesser explains how LLMs process text differently than humans, emphasizing that structural choices in prompts can impact results more significantly than word choice.

Let the Model Write the Prompt - Drew Breunig demonstrates how DSPy can be used to define and optimize LLM tasks, using a geospatial conflation problem as an example to show how the framework simplifies, improves, and future-proofs AI implementations.

First Malicious MCP in the Wild: The Postmark Backdoor That’s Stealing Your Emails - Koi reveals details about the first discovered malicious Model Composition Protocol (MCP) backdoor in the Postmark npm package that steals users’ email data.

Context engineering is sleeping on the humble hyperlink - the overlooked solution for efficient LLM context management.

Agentic Lessons learn after 300 agents - Sai Yashwanth - I have built around 300 agents, worked at 5 startups. Here’s what I learnt about AI Agent

Leadership co-processing with LLMs - James Stanier examines how large language models are transforming management practices through techniques for prioritization, communication, and cognitive offloading.

🎙️ YouTube & Podcasts

🔥How To Get The Most Out Of Vibe Coding - Guide to using AI as a coding partner to build faster by Y Combinator.

🔥🔥🔥 Prompting 101 | Code w/ Claude - Hannah Moran and Christian Ryan from Anthropic present fundamental prompting techniques for effectively working with Claude, covering essential strategies developers can use to improve AI interactions.

On Engineering AI Systems that Endure The Bitter Lesson - Building AI systems that last through principled engineering approaches.

🗞️ News and Social

Introducing gpt-oss - OpenAI releases Apache-licensed reasoning models optimized for consumer hardware.

Building agents with the Claude Agent SDK - Anthropic rebrands Claude Code SDK to reflect its broader agent capabilities beyond coding.

Google Labs introduces Opal - a new way to help you build and share AI mini-apps by linking together prompts, models, and tools— all while using simple, natural language

10 Principles of Building AI Agents: - by Pawel Huryn.

OpenAI experiments with new “Study together” tool on ChatGPT - ChatGPT’s new feature creates interactive learning experiences with guided study sessions.

THE WAY OF CODE - a project by n in collaboration with Anthropic:

Tessl launches spec-driven development tools for reliable AI coding agents

8 RAG architectures for AI engineers

Google’s MCP Toolbox for Databases is now open source! 🔥

AI tooling must be disclosed for contributions - AI disclosure requirement for contributions to ghostty-org.

🛠️ Tech & Tools

Agents.md: an open standard for AI coding agents - A file standard for consistent AI assistant instructions across projects.

GitHub - openai/gpt-oss: gpt-oss-120b and gpt-oss-20b - Open-weight models for reasoning and agentic tasks.

OpenCode | The AI coding agent built for the terminal - Open-source AI coding assistant for terminal that respects privacy.

Agent Leaderboard - a Hugging Face Space by galileo-ai - Comparative tool for AI agent performance with filterable metrics.

GitHub - traceloop/openllmetry - traceloop - OpenTelemetry-based observability for LLM applications.

GitHub - terryso/claude-auto-resume - Script that auto-resumes Claude CLI tasks after usage limits expire.

GitHub - f/awesome-chatgpt-prompts - A curated collection of prompts designed for ChatGPT and other LLM tools to help users get better responses from AI language models.

Kilo Code - coding agent for VS Code and JetBrains - AI coding assistant with project management capabilities serving 500k+ users.

GitHub - marcelsud/spec-driven-agentic-development - Specification-driven development framework for AI-assisted software building.

GitHub - charmbracelet/crush: 💘 - Terminal-based AI coding assistant for your workflow.

GitHub - Pimzino/claude-code-spec-workflow - Structured AI-powered development workflows for features and bug fixes.

GitHub - docker/cagent: Agent Builder and Runtime by Docker - AI agent orchestration tool for building collaborative virtual expert teams.

GitHub - kirodotdev/Kiro: Kiro is an agentic IDE that works alongside you - AI-powered IDE that understands your codebase and automates development tasks.

Product requirement document generation using LLM task oriented dialogue · GitHub - LLM-powered PRD generation through guided dialogue.

GitHub - davidkimai/Context-Engineering - First-principles handbook for AI context design and optimization.

GitHub - ashishpatel26/500-AI-Agents-Projects - Curated collection of AI agent applications with implementation resources.

GitHub - GoogleCloudPlatform/kubectl-ai: AI powered Kubernetes Assistant - AI-powered tool that simplifies Kubernetes management.

GitHub - hesreallyhim/awesome-claude-code - A curated resource list for maximizing Claude Code’s capabilities.

AI Coding Tools: Install Trends (based on Visual Studio Code) - Visual tracking of AI coding extension popularity in VS Code.

GitHub - invariantlabs-ai/mcp-scan: Constrain, log and scan your MCP connections - Security scanner for MCP servers detecting vulnerabilities across various configurations.

📚 Learning Picks

Think Python - Free, beginner-friendly Python programming book with interactive Jupyter notebooks.

GitHub - Asabeneh/30-Days-Of-Python: 30 days of Python programming challenge - Self-paced Python learning challenge with daily exercises.

Generative AI for Beginners - Microsoft’s 18-lesson course on building Generative AI applications.

GitHub - microsoft/ai-agents-for-beginners: 12 Lessons to Get Started Building AI Agents - Beginner-friendly AI agent development course .

🎭 AI Humor

Share

👋 See You Next Time

Thanks for reading Generative Programmer! 🙏 If you like the content please support my newsletter by subscribing and sharing with your network: X · LinkedIn · BlueSky · Email. Have a great rest of the week!

Subscribe now

🤖 What is an Agent?

The concept of software agents is not new. One of the earliest formal definitions comes from the influential 1996 paper “Is it an Agent, or just a Program? A Taxonomy for Autonomous Agents” by Stan Franklin and Art Graesser. In it, the authors proposed a formal distinction between agents and traditional programs, describing agents as:

“...autonomous systems that perceive their environment, act upon it, and pursue goals.”
(Franklin & Graesser, 1996, Third International Workshop on Agent Theories, Architectures, and Languages)

Fast forward nearly three decades, and the concept of an “agent” has become central to AI system design, especially with the rise of LLM-based agents.

A short and practical definition comes from in his post ‘agent’ may finally have a meaning”:

“An LLM agent runs tools in a loop to achieve a goal.”

This is also my favourite definition and it captures the essence of modern AI agents: they combine language models with external tools to reason, act, and iterate toward objectives.

Meanwhile, Gartner offers a more enterprise-aligned definition in their 2024 report “When to Use or Not to Use AI Agents”:

“AI agents are autonomous or semiautonomous software entities that use AI techniques to perceive, make decisions, take actions, and achieve goals in their digital or physical environments.”

In practice today, agents are often built on loop-based architectures, capable of planning, executing actions (e.g., calling APIs or tools), and learning over time. From LLM-powered assistants to multi-agent ecosystems, the agent model is a foundational pattern in building goal-driven AI systems.

🧩 Headless Agents

Headless agents emphasize a specific aspect of intelligence — decoupling it from any fixed (usually a chat) interface. As commonly defined:

“Headless AI agents are intelligent systems that operate without a fixed user interface, with their functionality exposed primarily through APIs or embedded directly into business systems and workflows.”

Just like a headless CMS separates content from presentation, headless AI agents separate intelligence from interaction. This allows developers and organizations to build AI capabilities once and deploy them invisibly across channels, web apps, backend services, IoT devices, and more, without duplicating logic or tying intelligence to a specific UI.

Key characteristics:

• Interface-agnostic intelligence: Reasoning and decision-making not tied to any specific UI, enabling reuse across channels.

• API-first operation: Invoked via APIs, events, or embedded logic, often running invisibly within larger workflows.

• Functionality over conversation: Unlike chatbots, their focus is performing tasks, not holding conversations.

Salesforce was among first to introduce a Headless Agent API, making this concept mainstream for enterprise-grade automation.

📡 Ambient Agents

Ambient agents are a specific type of headless agent that emphasize operating in the background, autonomous initiation, and context awareness.

As described by LangChain:

“Ambient agents listen to an event stream and act on it accordingly, potentially acting on multiple events at a time.”

These agents run quietly in the background, activated by signals, incoming emails, data updates, system triggers, or scheduled events, rather than human prompts.
They maintain full context awareness, tracking both current system states and past interactions to make informed, autonomous decisions.

When necessary, they introduce a human-in-the-loop through structured prompts such as:

• Notify: “Here’s something important you should see.”

• Question: “I need your input to proceed.”

• Review: “Here’s what I plan to do — approve or edit?”

Other key characteristics include persistent memory, tool-driven actions, multi-agent orchestration, and durability across long-running workflows.

In essence, ambient and headless agents share the same foundation of interface-free intelligence, but ambient agents place stronger emphasis on proactive, event-driven operation and human collaboration — making the two terms largely interchangeable in practice.

💾 Durable Agents

Durable agents emphasize durable execution, in contrast to non-durable agents, where execution state is typically held in memory and lost on failure or restart.

Durable agents persist their full execution history, allowing them to recover gracefully from crashes, restarts, or API failures without restarting the task or repeating actions.

As described by Pydantic AI:

“Durable agents can preserve their progress across transient API failures and application errors or restarts, and handle long-running, asynchronous, and human-in-the-loop workflows with production-grade reliability.”

Durability involves persisting not only the conversation history, but also every LLM call and tool invocation — so the agent can resume exactly where it left off. This avoids re-executing steps that may have side effects or lead to duplication which is a common problem in non-durable frameworks.

Different agentic frameworks achieve durability differently. For example, Pydantic integrates with systems such as Temporal, DBOS, and Prefect. In contrast, Dapr Agents, offer native support for durability via a built-in DurableAgent type. This agent type combine multiple traits:

• Headless – invokable via REST APIs, with no fixed interface

• Ambient – can be triggered by an event stream

• Durable – backed by a persistent workflow engine

Other frameworks offering durability include: Convex and Restate.

🧠 Deep Agents

Deep agents are an evolution of traditional (shallow?) agents with a goal to handle complex, multi-step tasks by combining planning, memory, and delegation. In reality, these are multi-agent systems with specialized sub-agents, and that’s an implementation detail.

As Philipp Schmid summarizes:

“These systems do not just react in a loop. They combine agentic patterns to plan, manage persistent memory/state, and delegate work to specialized sub-agents to solve multi-step, complex problems.”

Core components:

• 🗺️ Planning: Maintain an explicit task plan (a to-do list) that updates dynamically.

• 🧩 Sub-agents: A central orchestrator delegates tasks to specialized sub-agents (researcher, coder, writer, etc.).

• 💾 Persistent memory: Use external stores (files, vector DBs) to retain state and share results across steps.

This architecture makes deep agents more robust and modular, shifting design from reactive prompting to proactive problem solving.

⚙️ Agentic Workflow

This is not an agent type, but how some agents operate. There are still conflicting definitions of Agentic Workflows. I ran a poll asking:

What is an Agentic Workflow?
1️⃣ A deterministic workflow where agents execute predefined steps.
2️⃣ A human-defined goal, where an agent dynamically plans and executes a workflow to reach it.

After the discussion, the consensus leaned strongly toward option 2 — a human-defined goal where an agent dynamically plans and executes a workflow to reach that goal.

Here is a concise definition from IBM (with Weaviate offering a similar one):

“Agentic workflows are AI-driven processes in which autonomous AI agents make decisions, take actions, and coordinate tasks with minimal human intervention. They use reasoning, planning, and tool use to execute complex, dynamic, multistep workflows that adapt to real-time data and changing conditions, unlike traditional rule-based automation.”
— IBM,

In short, agentic workflows are when agents define a plan (workflow) and runs itself, reasoning, adapting, and acting toward a defined goal.

This is a fast-moving space and new terms appear weekly. If you come across a new agentic concept or definition that deserves to be added here, share it. I’ll keep updating this post as the vocabulary evolves.

🔥 Top Picks from Summer of 2025

📘 Agent Design Pattern Catalogue -Yue Liu 🔥
🧠 How to Fix Your Context – Drew Breunig
⚙️ AI Agent Workflow Design Patterns – Craig Li
🏗️ The Big LLM Architecture Comparison – Sebastian Raschka 🔥
💡 Why Applications & Pipelines Should Use DSPy – Drew Breunig
🛠️ AI Coding Tools Can Actually Reduce Productivity – Second Thoughts
🏢 Agentic AI Architecture Framework for Enterprises – InfoQ
⚡ Understanding the KV Cache in LLMs from Scratch – Sebastian Raschka
🎥 Mastering Claude Code in 30 minutes – Claude Code team
☠️ Replit goes rogue during a code freeze and deletes an entire prod database

…and if you dare, 100+ updates to explore 👇

Share

🎯 Featured Article

Agent Design Pattern Catalogue – Yue Liu and colleagues present 18 architectural patterns for building foundation model-based agents.

Agentic systems and architectural patterns ecosystems

The catalogue covers context, forces, and trade-offs in agent design, and introduces a decision model to help practitioners address challenges like hallucinations, explainability, and accountability. A comprehensive guide for anyone architecting agentic systems. 🔥

📰 Building Agentic Systems

How to Fix Your Context | Drew Breunig - Techniques for managing context in AI to avoid "garbage in, garbage out" problems.

Agentic Mesh for Regulatory Compliance: EU AI Act & DORA Integration

AI Agent Workflow Design Patterns - Craig Li introduces the implementation of an agent framework based on AI Agent Design Patterns while researching various workflow patterns that combine LLM reasoning capabilities, memory, and task execution.

Agentic Engineering in Action - Mitchell Hashimoto explains his AI-assisted development approach for Ghostty.

Context Engineering - What it is, and techniques to consider - A guide to providing AI agents with relevant context for effective task performance.

Pydantic Agents and Human-in-the-Loop - Lalit demonstrates how to build AI agents with PydanticAI that incorporate human feedback when faced with ambiguous situations, using a weather information system as a practical example.

Agents are not tools - Google Developer forums - This post examines the crucial distinction between agents and tools, highlighting how their different decision-making control flows require unique interaction approaches.

Understanding Tool Calling with Step-by-Step Examples in REST and Spring AI - Muthukumaran Navaneethakrishnan provides a comprehensive guide on implementing OpenAI-style tool calling in LLMs, with practical code examples in both REST and Spring AI, complete with diagrams and end-to-end implementation flows.

MCP vs. A2A: Friends or Foes? - Aurimas Griciūnas examines how Google's new A2A protocol competes with Anthropic's MCP in the race to establish standards for multi-agent AI system communication.

Agentic AI Architecture Framework for Enterprises - InfoQ - Enterprise framework for building autonomous AI systems that can plan and execute tasks independently.

Context Engineering: Bringing Engineering Discipline to Prompts - Osmani: Give AI complete context, not just clever prompts.

CodeAct - Apple researchers propose using executable Python code as a unified action space for LLM agents, enabling more flexible tool composition and dynamic action revision compared to traditional JSON or text-based formats.

The Open-Source Toolkit for Building AI Agents v2 - Updated toolkit overview for AI agent developers.

Context Is the New Compute: Designing the Future of Agentic - Gill: Context engineering replaces prompt engineering as AI agents grow more complex.

Context Engineering for AI Agents: Lessons from Building Manus - Manus team shares optimized principles for AI agent development based on their own experiences, offering valuable shortcuts for developers building similar systems.

Executable Code Actions Elicit Better LLM Agents - Xingyao Wang: Code-based actions enhance LLM agent effectiveness.

📰 Coding with AI

Leading your engineers towards an AI-assisted future - Pete Hodgson questions whether the team is leveraging AI coding tools enough.

Coding for the Future Agentic World - examines how AI agents are transforming software development workflows.

Rethinking CLI interfaces for AI - CLI tools need AI-friendly redesigns to balance context windows and information needs.

Coding with LLMs in the summer of 2025 - Antirez: A forward-looking analysis of AI-assisted programming in 2025.

AI Coding Tools Can Actually Reduce Productivity - Study shows AI coding tools may hinder experienced developers' productivity.

Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity - METR - Joel Becker's overview of the report.

Software engineering with LLMs in 2025: reality check - Gergely Orosz shares insights from discussions with engineers at leading AI companies about current AI tool usage patterns and emerging trends in software development.

LLMs bring new nature of abstraction - Martin Fowler: LLMs fundamentally change programming by introducing non-deterministic abstraction.

Vibe-Coding a PCB - surprisingly good - Chris Greening demonstrates how AI can successfully design functional hardware

Vibecoding a high performance system - AI-assisted development of a billion-page web crawler with minimal manual coding.

Leading your engineers towards an AI-assisted future | Pete Hodgson - A conversation about balancing AI hype with practical engineering value.

How to spot AI Generated Code - Brian White-Starrs on LinkedIn

From vibe coding to vibe planning - AI Native Dev's article examines a real-world incident where an AI coding assistant deleted a production database during "vibe coding," highlighting the dangers of unleashing AI on live codebases and Replit's subsequent response to improve safety.

Parallelizing AI Coding Agents | AI Native Dev - The author examines the evolution of AI coding from simple prompting to autonomous agents, highlighting how parallel agent architecture creates faster but more complex workflows similar to asynchronous programming models.

Coding agents have crossed a chasm

AI Agents, meet Test Driven Development - Applying TDD principles to AI agent development workflows.

Agentic Coding Recommendations - Armin Ronacher shares his practical workflow for agentic coding, detailing his preference for Claude Code with the Max subscription and how he optimizes for token efficiency while giving agents full permissions.

Learnings from two years of using AI tools for software engineering - Practical insights from a Thoughtworks engineer's two-year AI tools exploration.

📰 Long-Form Reads

You Got Commands in My Prompt! - Breunig: New Qwen 3 models let you control reasoning with simple prompt commands.

The Big LLM Architecture Comparison - Raschka analyzes LLM evolution: incremental tweaks or true innovation?

Why Applications & Pipelines Should Use DSPy - Breunig explains using DSPy to let models write their own prompts.

MCP market map - Finsweet examines how the Model Context Protocol (MCP) is evolving from a technical specification into a thriving ecosystem with commercial opportunities similar to the API economy, but accelerated by AI integration.

Building tiny AI tools for developer productivity - Title says it all

How has AI impacted engineering leadership in 2025? - Lizzie Matusov examines the 2025 Engineering Leadership Report which surveyed 617 engineering leaders

How Bolt hit 40M ARR in 5 months - Kyle Poyar: AI app builder goes from near-shutdown to $40M ARR overnight.

Your API might be someone else's model- CORS protects APIs from unauthorized use, similar to emerging AI model protection needs.

Autonomy Sliders - examines the concept of autonomy sliders, likely discussing how to balance AI system independence with human oversight and control.

Seeing like an LLM - Krishnan compares LLM functionality to human learning and knowledge limitations.

MCP Authorization in 5 easy OAuth specs - WorkOS - OAuth standards for secure MCP authorization with LLMs.

Recovering from AI Addiction – Internet and Technology Addicts Anonymous - Stanford: A support community for overcoming technology addiction.

The Tiny Teams Playbook - by Shawn swyx Wang - Framework for building small, hyper-efficient AI-powered teams that prioritize efficiency over scale.

Do developers need to think less with AI? - Thoughtworks' author challenges the common assumption that AI tools require more developer thinking, not less.

Why Google's Agent2Agent Protocol Needs Apache Kafka - Kafka offers critical messaging capabilities for Google's multi-agent AI communication protocol.

Do Machine Learning Models Memorize or Generalize? - Explores how models transition from memorization to genuine understanding during extended training.

Phoenix.new is Fly's entry into the prompt-driven app development space - Fly.io launches tool that creates Phoenix apps from text prompts.

Researchers hide AI prompts in papers - Researchers caught hiding instructions for AI to give favorable paper reviews.

Experimenting with LLMs for semantic testing - Semantic testing validates content meaning beyond functional correctness.

Understanding and Coding the KV Cache in LLMs from Scratch - Sebastian Raschka breaks down KV caches: how they speed up LLM inference by storing key-value computations.

A Survey: 2025 AI Newsletters - Michael Spencer's extensive list of AI newsletters with upcoming LinkedIn influencer guide.

Death by a thousand slops - Daniel Stenberg: Curl project drowning in AI-generated vulnerability report spam.

Why I'm Betting Against AI Agents in 2025 (Despite Building Them) - Experienced agent builder explains why autonomous AI agents won't deliver on 2025 promises.

How to use AI to Optimize your Personal Life and Free Time - Daria Cupareanu: AI strategies for reclaiming time and enhancing personal life quality.

Leadership co-processing with LLMs - James Stanier discusses how LLMs are changing management roles and practices.

🎙️ YouTube & Podcasts

Andrej Karpathy: Software Is Changing (Again) - YouTube - Karpathy explores AI's revolutionary impact on software development paradigms. 🔥🔥🔥

Mastering Claude Code in 30 minutes - YouTube - Quick guide to Claude Code's advanced features and shortcuts. 🔥

Software engineering with LLMs in 2025: reality check - YouTube - The Pragmatic Engineer’s Gergely Orosz presents a comprehensive overview of how developers at AI startups and Big Tech companies are currently using AI tools, featuring projections about the future landscape of software engineering.

🗞️ News and Updates

Gergely Orosz's take on X - Being able to specify what software you want to build, how it should be structured, and how exactly it should work is... programming. And getting into the weeds, when needed.

Batch Mode in the Gemini API: Process more for less - New Gemini API feature offers discounted batch processing for non-urgent AI tasks.

Whats Your Best Advice For Using Claude Code [Reddit] - Reddit thread collecting Claude code usage tips.

10 Principles of Building AI Agents - Paweł Huryn on X

MCP Authorization specs - Christian Posta on X

OpenAI experiments with new "Study together" tool on ChatGPT - New ChatGPT feature creates interactive learning with step-by-step guidance.

AWS introduced Kiro on X -Introducing Kiro, an all-new agentic IDE that has a chance to transform how developers build software.

Replit goes rogue during a code freeze and shutdown and deletes our entire database

🛠️ Tech & Tools

Backlog.md - Git-based Markdown task manager with Kanban visualization.

install.md - Tools that help coding agents integrate various software components into codebases through MCP server technology.

Browserbase - A specialized web browser designed specifically for AI agents and applications to interact with web content.

spec-driven-agentic-development - A specification-based workflow for AI-assisted software development.

BrowserStack - AI-powered test case generation from requirements documents.

any-agent - mozilla-ai - A unified interface that allows developers to use and evaluate different AI agent frameworks through a single implementation.

📚 Learning Picks

Claude Code in Action - Skilljar hosts Anthropic course materials for organized, interactive learning.

ai-agents-for-beginners - Microsoft's beginner-friendly AI agent development curriculum with multilingual support.

🎭 AI Humor

Share

👋 See You Next Time

Thanks for reading Generative Programmer! 🙏

If you like the content please support my newsletter by subscribing and sharing with your network: X · LinkedIn · BlueSky · Email. Have a great rest of the week!

Subscribe now

1. Rapid User Story Creation via Custom GPT

One of the most common tasks a PM has to do is create user stories, PRDs, log bugs and tasks. There are many custom GPTs for PRD creation, from services to sophisticated custom prompt templates. But each company and team has its own preferred format and style.

For this purpose I use custom GPTs from ChatGPT and created my own custom GPT. This lets me go from a short text or Slack message to ready-to-copy text for issue tracking systems. The template handles the formatting, ensures I don't miss edge cases, and maintains consistency across the backlog. For any repetitive task done on ChatGPT, consider creating a custom GPT with the desired context and prompt. I use many custom GPTs, a few are pubic such as Title Generator, Jargon Cleaner, and many more are private and used in professional setting.

2. Dictation Over Typing for Richer Context

I use ChatGPT for all kinds of quick searches (instead of googling) or writing short messages, or taking notes. For short interactions, starting ChatGPT, telling AI what you want and passing the context is the bottleneck. The best way to do that is through voice input rather than typing. However, the default workflow requires multiple clicks: open ChatGPT, click on voice, talk, stop voice, then send the text. I use it so much that I vibe coded a Chrome plugin to automate that.

With this plugin, I can use a single keyboard shortcut to start ChatGPT and start talking immediately. Hit ALT + SHIFT + SPACE to open a new ChatGPT tab, with dictation started. This eliminates the friction and makes voice input as fast as opening any other native app.

3. Brainstorming and Problem Solving via Voice Mode

I use ChatGPT mobile app voice mode (notice this is different than dictation input mentioned above) primarily when I'm out walking or at the gym and have an idea that needs development. Instead of just asking for a list of suggestions, I have actual conversations where I ask ChatGPT to challenge me back and forth. For example, when writing this blog post, I asked ChatGPT to "act as an expert in AI adoption, be critical of my thinking, and challenge my ideas until we come up with a solid plan…" I use this for brainstorming content ideas, preparing for meetings, working through problems I don't have a clear solution for, or exploring new domains and discovering blindspots with back-and-forth discussion. The voice interaction lets me think out loud and get immediate pushback on weak concepts, making it like having a sparring partner who helps refine ideas in real-time.

4. Deep Search and Extended Thinking

This is one of the methods that saves me the most time since using AI for research. I use AI to do comprehensive research where I give very detailed, specific tasks with clear goals and outcomes. For example, I can perform competitive product analysis, deep project/technology comparisons, marketing plans for product launches, or ecosystem mapping with different players and get very detailed and structured write-ups.

A trick I use here is to perform the same research across 2-3 AI products simultaneously - ChatGPT, Claude, and Grok from X - then compare their outputs. Each AI often surfaces different angles or insights, giving me a more complete picture than relying on a single source. This parallel approach catches blindspots and validates findings.

5. Data Analysis and User Feedback Mining

I use AI to process large amounts of unstructured text data to extract insights. I identify trends, challenges, and bugs by gathering feedback not directly, but from large datasets and synthesizing insights. For example, if you work in a company, you know where users are hanging out - community forums, Discord channels, Reddit discussions, support tickets, or social media mentions. I paste all that data into AI and ask it to identify challenges, trends, or specific issues people are unhappy with. You can also do this by exporting data from various systems you have, and ask AI to identify trends or even generate graphs to show these trends and so forth.

A typical prompt would be: "Analyze this data and give me the top three challenges users are facing, the top three feature requests, and the top three things people are most satisfied with." Extracting insights and displaying trends from raw and unstructured data is a core PM task that AI excels in, helping me prioritize roadmap items based on real-world signals rather than assumptions.

6. Docs from Engineering Notes and Code

As a product manager, you often have tight deadlines with limited input from the busy engineering teams. For example, you may have new features launching soon but insufficient documentation from the platform team. What you can do is feed AI with engineering notes, PRs, and even source code to describe what has been implemented in a specific release. For instance, when a major feature ships, you can also provide additional context by uploading existing product documentation.

Claude’s Projects feature allows you to attach context from Github repositories, specific files, or documentation that can be referenced multiple times. You can attach this context to a project, and once created, that project can be reused across multiple chats with all the relevant context automatically available. This Projects feature is particularly useful for writing documentation or content that needs to follow a specific format and requires lots of context to maintain consistency.

7. Screenshot Reviews and Visual Analysis

AI is good not only with text and voice, but also with visual inputs. One input method that's not used as much is the imaging. This is particularly useful for getting feedback on UI designs. For example, you can feed in a design mockup or screenshot and ask it to review the text, layout, and suggest improvements from a UX perspective. Another way to use visual input is for data analysis - you can upload charts, graphs, or dashboards and ask AI to interpret trends or suggest better ways to visualize the data.

8. Code Explanation via Cursor and AI Tools

I use AI tools to understand code when documentation is lacking, but for this purpose, I find that tools specialized in code creation - IDEs and CLIs - are much better generic AI tools like ChatGPT and Claude. That's why my preferred option here is to use something like Cursor (in asking mode rather than agent mode), which can give me very detailed explanations with proper context. I can give these specialized tools a specific file from a project, a specific package, or ask them to analyze a whole project and explain various aspects.

For example, I might ask "How does DurableAgent class work?" in Dapr Agents, or "what are the edge cases and exception scenarios?" The AI can analyze the code and give a detailed description of how it works, which I use for my own understanding, testing strategy, or when discussing feature requirements with engineering teams.

9. Mockup Prototyping via AI Code Generation

Tools like v0 from Vercel, Lovable, Bolt (and many others) have created a new wave of AI-powered prototyping that can generate actual working code. You can describe a feature concept and get a functional prototype that demonstrates the user flow and basic interactions. This serves almost as a specification that explains how a component should be built, which the engineering team can then take and recreate in a proper production environment. While this is the most talked about use case for PMs and AI, for me this is too wasteful an approach to recreate a whole app to explain a requirement and concept. This approach works best when the complexity is in the UI rather than the backend behaviour.

10. Creating Examples, Quickstarts, and Non-Critical Code

As a product manager, you sometimes need to write code, and even if you're not comfortable or working with newer languages and frameworks you don't know. While you're not an engineer writing production code, AI is perfect for creating examples, quickstarts, demos, and non-critical automation scripts.

For instance, I wrote (generated) bash scripts to automate the creation of reports from API calls, or generate examples for documentation, quickstarts, even training materials. You can ask AI to generate the code, then have an engineer review it before implementation. This approach speeds up the development process and actually helps you use your own product from a user's perspective. It can even help you learn a new language or a framework by doing rather than only reading.

That’s my playbook for putting AI to work in product management. I’m always looking for new ideas. How are you using AI to get the biggest gains in your work?

If you like the content please support my newsletter by subscribing and sharing with your network: X · LinkedIn · BlueSky · Email. Have a great rest of the week!

🔥 Top Picks from June

📘 The Prompt Engineering Playbook for Programmers – Addy Osmani 🔥
🤖 How we built our multi-agent research system – Anthropic 🔥
💡 Software Is Changing (Again) – Andrej Karpathy 🔥
🔐 The future of AI agents—and why OAuth must evolve – Alex Simons
🧑‍💻 Why Go is a good fit for agents – Hatchet Team
🛠️ Design Decisions Behind app.build, a Prompt-to-App Generator – Neon
⚙️ Understanding the KV Cache in LLMs from Scratch – Sebastian Raschka
🏢 Zapier's AI-first hiring and onboarding – Zapier
🎥 12-Factor Agents – Dex Horthy 🔥
🧠 Context Engineering – Langchain
📊 This AI Agent Should Have Been a SQL Query – Gunnar Morling
🧬 Prompt Engineering – Lilian Weng 🔥

…and if you dare, 100+ updates to explore 👇

Share

🎯 Featured Article

The Prompt Engineering Playbook for Programmers - demonstrates how prompt engineering has become an essential skill for developers using AI coding assistants, outlining systematic approaches to craft effective prompts that yield high-quality code solutions rather than generic outputs. A MUST READ👇

📰 Long-Form Reads

Understanding and Coding the KV Cache in LLMs from Scratch - Sebastian Raschka breaks down KV caching for faster LLM inference with code examples. 🌟

Block's Playbook for Designing MCP Servers - A practical guide to mission-critical MCP server design.🌟

The Dark Side of "Just Hooking Up" AI Agents to GitHub - Folks at AI Native Dev examines the security risks and potential vulnerabilities that emerge when developers integrate AI agents with GitHub repositories without proper safeguards or oversight.

Do Machine Learning Models Memorize or Generalize? - The author investigates the "grokking" phenomenon where models unexpectedly learn to generalize after extended training.

GitHub - humanlayer/12-factor-agents - principles for production-quality LLM agents based on real-world implementation patterns.🌟🌟🌟

Evaluating Large Language Model (LLM) systems: Metrics, challenges, and best practices - Jane Huang breaks down systematic LLM evaluation beyond simple prompt testing.

How we built our multi-agent research system \ Anthropic - reveals how Anthropic built Claude's multi-agent research system for complex information gathering. 🌟🌟🌟

How Google is accelerating code migrations with AI - Abi Noda reveals Google's AI techniques for faster, more efficient code migrations.

Prompt Engineering - Lilian Weng details techniques for steering LLM behavior without updating model weights, emphasizing that prompt engineering is an empirical science requiring experimentation across different models.🌟🌟

Vibe coding is rewriting the rules of technology - Kiara Nirghin explains how AI-powered development prioritizes intent over code syntax.

Kai Waehner explains how OpenAI uses Apache Kafka and Flink for GenAI

The "Trust, But Verify" Pattern For AI-Assisted Engineering - Addy Osmani explains why developers must treat AI coding assistants like junior developers, requiring thorough verification of AI-generated code while maintaining human accountability for all output.

How AI generated code compounds technical debt - LeadDev - Bill Doerrfeld examines how LLM-based coding assistants are making it easier to create code but simultaneously undermining engineering best practices like DRY, leading to increased code duplication and declining quality.

The future of AI agents—and why OAuth must evolve - Alex_Simons examines the need for collaborative development of identity standards to enable AI agents to securely access and operate across different systems.

LLM Shibboleths determine AI effectiveness - Author reveals why developer expertise determines AI coding assistant value.

Highlights from the Claude 4 system prompt - Simon Willison unpacks Claude 4's system prompts, revealing AI guardrails and capabilities.

Building software on top of Large Language Models - Simon Willison shares insights on LLM tools and free content philosophy.

How ChatGPT Remembers You: A Deep Dive into Its Memory and Chat History Features - wunderwuzzi's

My AI Skeptic Friends Are All Nuts · The Fly Blog - Thomas Ptacek argues that LLMs have fundamentally changed software development despite skepticism from tech leaders, noting that talented developers are refusing to use tools that already outperform them purely out of resistance to change.

Evaluation Driven Development for Agentic Systems. - Aurimas Griciūnas reveals how evaluation-driven methodologies improve AI agent development.

Claude Code saved us 97% of the work — then failed utterly - Thoughtworks: AI coding assistant shows promise but has critical limitations.

The Open-Source Toolkit for Building AI Agents - Sahar Mor reveals essential open-source tools for creating AI agents.

What Even Is Vibe Coding? - Ashley Willis: From skepticism to curiosity about Karpathy's "vibe coding" concept.

Domain-Driven RAG: Building Accurate Enterprise Knowledge Systems through Distributed Ownership - George Panagiotopoulos reveals how distributed domain ownership improves RAG system accuracy. 🌟

Announcing AWS Security Reference Architecture Code Examples for Generative AI | AWS Security Blog - AWS launches security templates for securing generative AI implementations.

Developing Apps by Chat: How Far Can Lovable 2.0 Really Go? - Baptiste Fernandez examines the potential and boundaries of conversational app development with Lovable 2.0.

Zapier's AI-first hiring and onboarding - New hires must now demonstrate AI fluency as standard requirement.🌟

The last six months in LLMs, illustrated by pelicans on bicycles - Simon Willison covers recent LLM developments with creative imagery, ChatGPT prompting tips for a UK official, plus curated links and quotations for AI enthusiasts.

Modernizing Legacy Struts2 Applications With Claude Code - Damien Gallagher demonstrates AI-assisted migration from Struts2 to modern frameworks.

Adopting Docs-as-Code at Pinterest - Pinterest Engineering reveals their shift to docs-as-code after traditional documentation methods failed.

How we built our AI code review tool for IDEs - CodeRabbit

God is hungry for Context: First thoughts on o3 pro - Ben Hylak reveals: OpenAI slashes o3 pricing while launching superior o3-pro variant.

Radar Trends to Watch: June 2025 – O'Reilly

SWE Agents Too Cheap To Meter, The Token Data War, and the rise of Tiny Teams - Latent.Space explains how recent AI coding agents like Codex and Jules are being offered at no extra cost, encouraging developers to maximize their usage while highlighting upcoming AI engineering events and the trend of smaller development teams.

Can AI Replace Software Architects? I Put 4 LLMs to the Test - CloudWay

LLMs are cheap - Mikael Snellman challenges the common misconception that Large Language Models are prohibitively expensive to operate

Why Go is a good fit for agents - Hatchet team notes Go's growing popularity in hybrid tech stacks for agent development.

Why agents are bad pair programmers - Justin Searls: AI agents code faster than humans think, creating poor pairing dynamics.

How I program with Agents - Crawshaw explores using AI agents as programming tools beyond simple autocomplete.

Securing AI agents: A guide to authentication, authorization, and defense - WorkOS explains how to secure autonomous AI systems in applications.

Agentic Coding Recommendations - Armin Ronacher reveals his cost-effective, token-optimized approach to AI coding assistants.

Don't Build Multi-Agents - Walden Yan from Cognition outlines why multi-agent systems fail and what works instead.

The state of AI agents - Lance Martin details the rise of autonomous background AI agents.

Context Engineering - Folks at Langchain examines techniques for managing LLM context windows efficiently.

AI Agents, meet Test Driven Development - Anita Kirkovska: Adapting TDD practices for more reliable AI agent development.

Takeaways from the AI Engineer World's Fair... - Patrick Ellis

Trying out the new Gemini 2.5 model family - Simon Willison reviews Gemini's new models with improved pricing and performance.

How to Vibe Code as a Senior Engineer - Alex Maccaw reveals how AI transforms coding from expensive to efficient.

Introducing MCP Catalog and Toolkit - Mark Cavage highlights Docker's vision for standardizing AI agent-tool connections with MCP.

AI as Normal Technology - Nicholas Bagley argues AI should be viewed as normal technology, not superintelligence.

The agent-first developer toolchain: how AI will radically transform the SDLC - Amplify Partners: AI needs new dev toolchains, not just upgrades to old ones.

Design Decisions Behind app.build, a Prompt-to-App Generator - Arseny Kravchenko details how Neon's app.build was engineered to prioritize reliability over feature complexity through scope limitations, FSM-guided tree-search, extensive validation systems, and an error analysis feedback loop.🌟

AI Engineering Goes Mainstream - Latent.Space shows the evolution of AI Engineering into a recognized professional discipline.

Benchmarking Multi-Agent Architectures - Will Fu-Hinthorn compares multi-agent systems and reveals key performance improvements.

Fuck You, Show Me The Prompt - Hamel Husain warns against tools that hide prompts from developers.

Gen AI Evaluation Service — Computation-Based Metrics - Mete Atamel dives into computation-based metrics in Vertex AI's evaluation service, explaining their deterministic nature, requirement for ground truth references, and limitations in capturing language nuances.

Why I'm Dialing Back My LLM Usage — Zed's Blog - Engineer's journey from LLM enthusiasm to practical skepticism.

Coding agents have crossed a chasm // flurries of latent creativity

Augmented Coding: Beyond the Vibes - Kent Beck shares insights from building a B+ Tree with AI assistance.

The AI-Native Software Engineer - explains how software engineers can adopt an AI-native mindset, treating AI as a collaborative partner that can dramatically amplify productivity and creativity rather than viewing it as a threat. 🌟🌟🌟

How to Stop Your Human From Hallucinating - Shrivu Shankar reveals strategies for managing AI hallucinations in workflows.

The DNA of AI Agents: Common Patterns in Recent Design Principles - Cedric Chee compares AI agent design frameworks, revealing shared patterns across different approaches.

From Prompt to Code - Paul Datta breaks down how Gemini CLI translates prompts into executable code.

The rise of "context engineering" - LangChain details how properly engineered context helps LLMs perform reliably.

Project Vend: Can Claude run a small shop? - Anthropic: AI-run store experiment shows Claude's potential and pitfalls in autonomous business management.

Context Engineering for Agents - Lance Martin explains what goes into an LLM's limited context window for better agent performance.

This AI Agent Should Have Been a SQL Query - Gunnar Morling contrasts pull-based SQL with push-based streaming queries.

37 Things I Learned About Information Retrieval in Two Years at a Vector Database Company - Leonie Monigatti reveals key vector database lessons from industry experience.🌟

Developing with GitHub Copilot Agent Mode and MCP - Austen Stone reveals VS Code settings for customizing AI assistants to enhance coding efficiency.

How Long Contexts Fail - Drew Breunig: Bigger AI context windows don't always mean better results.

The New Skill in AI is Not Prompting, It's Context Engineering - Philipp Schmid reveals why context quality trumps prompting in modern AI systems.

Context Engineering - What it is, and techniques to consider - Tuana Çelik and Logan Markewich guide to designing AI systems with optimal contextual awareness.

Hussein Mozannar - Hussein Mozannar shares a web agent development tutorial.

Building good agents - Smolagents shares essential practices for creating functional AI agents.

🎙️ YouTube & Podcasts

Claude Code: Anthropic's CLI Agent - YouTube - Video explores Anthropic's new CLI coding tool amid intensifying AI coding competition.

AI Product Management - YouTube - Aakash Gupta presents a comprehensive crash course covering essential AI PM skills from prompting to AI agents, designed to equip viewers with the knowledge needed to become effective AI product managers.

MCP vs ACP vs A2A: Comparing Agent Protocols - YouTube - Laurie Voss compares major agent protocols for AI resource integration.🌟

RAG vs. CAG - YouTube - This video explores the differences between Retrieval-Augmented Generation (RAG) and Context-Augmented Generation (CAG).

Software Is Changing (Again) - YouTube - Andrej Karpathy reveals how AI is revolutionizing software development practices. 🌟🌟 🌟

12-Factor Agents - YouTube - Dex Horthy reveals best practices for building dependable AI agent systems. 🌟🌟 🌟

🗞️ News and Updates

THE WAY OF CODE

X - next level openai codex abuse

Build AI agents with the Mistral Agents API - Mistral introduces new Agents API.

X - an easy way to extract ChatGPT's memory of you and metadata

X - Min Choi's new development flow

X - Aurimas' RAG vs CAG

Vibes, Rules, it's getting messy! - Dion Almaer examines the evolving tension between intuitive "vibe-based" development approaches and traditional rule-based methodologies in AI-native development environments.

Doubling Down on Open Source - Langfuse announces: All features now MIT-licensed for free self-hosting.

X - Context Engineering

X - did you know ChatGPT gave you free Windows 10 Pro keys!

🛠️ Tech & Tools

GitHub - x1xhlol/system-prompts-and-models-of-ai-tools: FULL v0, Cursor, Manus, Lovable... - extensive AI tool prompts and models for developer reference. 🌟🌟🌟

Repo Prompt - A frictionless app for AI-powered code iteration.

GitHub - mindsdb/mindsdb - A unified AI query engine for connecting and extracting insights across scattered data sources.

StreamNative Agent Engine: Event-Driven Runtime for Real-Time AI Agents

Claude Code – Hidden‑Gems - power features for maximizing Claude's capabilities.

GitHub - going-doer/Paper2Code: Paper2Code: Automating Code Generation from Scientific Papers

Zed — The editor for what's next - A Rust-built code editor integrating AI for collaborative development.

GitHub - BoundaryML/baml - A language for reliable AI prompts with multi-language support.

GitHub - github/github-mcp-server: GitHub's official MCP Server - for connecting GitHub APIs with developer tools.

GitHub - GoogleCloudPlatform/cloud-run-mcp - MCP server to deploy apps to Cloud Run

sketch.dev - A containerized coding assistant for parallel development workflows.

GitHub - sst/opencode - a terminal-based AI coding assistant that helps developers integrate AI capabilities directly into their command line workflow.

codename goose - a customizable local AI assistant for developers that automates complex tasks.

Cursor – Background Agents - Cursor introduced asynchronous code agents that work independently and push to GitHub.

KaibanJS - Kanban-inspired JavaScript framework for orchestrating AI agent systems.

GitHub - dagger/container-use - Containerized environments for multiple AI coding agents to work independently.

Kimi-Dev-72B - open-source coding model trained to fix real code issues.

Terminal-Bench - Netlify presents a benchmark for measuring AI agents' terminal capabilities.

Hooks - Anthropic - Did you know, Anthropic has customizable shell commands for extending Claude Code with automated behaviors.

Introducing Qodo Gen CLI - New CLI tool for building and running AI agents anywhere, and transform any IDE into an agentic environment.

Dosu | You build. Dosu documents. - A tool that converts codebases into living documentation for all team members.

📚 Learning Picks

AI Explorables | PAIR - PAIR team breaks down complex ML concepts through interactive essays.

Building software on top of LLMs - Simon Willison demonstrates LLM integration techniques for developers at PyCon 2025.

GitHub - langchain-ai/rag-from-scratch - Langchain-ai demonstrates how to build RAG systems from scratch to expand LLM capabilities.

🎭 AI Humor

🙃 source

Share

👋 See You Next Week

Thanks for reading Generative Programmer! 🙏

If you like the content please support my newsletter by subscribing and sharing with your network: X · LinkedIn · BlueSky · Email. Have a great rest of the week!

Subscribe now

There's no established classification system for AI agent protocols, but this white paper has emerged as the most popular approach recently. Understanding these key dimensions helps organize the growing ecosystem of protocols.

• Context-Oriented vs. Inter-Agent

  • Context-Oriented protocols enable agents to connect with external resources such as databases, APIs, tools, and services. These protocols standardize how agents acquire context and invoke capabilities beyond their core LLM, essentially acting as a bridge between AI and existing systems.

  • Inter-Agent protocols facilitate communication between multiple agents, enabling collaboration, task delegation, and distributed problem-solving. They define how agents discover each other, negotiate capabilities, and coordinate workflows across different systems or vendors.

• General-Purpose vs. Domain-Specific

  • General-Purpose protocols support broad use cases across industries and applications. They provide universal interfaces that work with diverse agent types, tools, and scenarios, prioritizing flexibility and wide adoption over specialized optimization.

  • Domain-Specific protocols are optimized for particular environments or use cases like human-agent interaction, robot coordination, IoT integration, or enterprise workflows. They sacrifice broad compatibility for deep functionality in their target domain.

Some protocols blur these boundaries by offering general frameworks with domain-specific extensions, or providing both context acquisition and inter-agent capabilities within a unified specification.

TLDR

This space is moving incredibly fast, but if all you want something that actually works in production today, there are really only 3 options:

• MCP - 100K+ GitHub stars, the clear winner from Anthropic

• A2A - 20K+ stars, Google's enterprise play

• AG-UI - 4K+ stars, focused on agent-to-UI communication

Agent Protocol and agents.json recently passed 1K stars and everything else is sub-1K stars and mostly experimental and even theoretical.

The List

Model Context Protocol (MCP)

MCP is Anthropic's universal protocol for connecting LLM agents to external resources through a client-server architecture. Uses JSON-RPC for standardized tool invocation and data access while decoupling sensitive operations from LLM responses. Provides a unified interface for integrating databases, APIs, and services across different LLM providers. Most adopted protocol currently. Does not focus on agent-to-agent communication. Lacks strong async support (to be addressed). No registry, authorization, or reputation system yet. Highly duplicative of other protocols, but adopted.

Agent2Agent (A2A)

Google's protocol for complex agent collaboration using HTTP(S), JSON-RPC 2.0, and Server-Sent Events. Emphasizes async-first architecture with task management, multimodal support, and built-in enterprise security features. Enables agents to collaborate through capability discovery and user experience negotiation without sharing internal implementation details. Built on existing protocols with strong async support specifically for long-running agent interactions.

AG-UI Protocol

Lightweight, event-driven protocol standardizing AI agent connections to front-end applications through streaming HTTP interfaces. Implements 16 typed event categories (lifecycle, messages, tool calls, state management) with support for Server-Sent Events and binary protocols. Features bidirectional state synchronization using JSON Patch deltas, real-time UI updates, and human-in-the-loop workflows through Observable-based agent execution model.

agents.json

OpenAPI-based specification for making websites AI-agent compatible through machine-readable contracts. Hosted at /.well-known/agents.json, it defines flows (multi-step API sequences) and data dependencies between actions. Enables agents to discover and interact with web services without custom prompt engineering or integration work. Describes not just API calls but how to chain them together to achieve goals.

Agent Network Protocol (ANP)

Open-source protocol for cross-domain agent communication using W3C DID standards for decentralized identity. Features three layers: identity/encryption, meta-protocol negotiation, and application protocols for agent discovery and interaction. Designed to create an "Internet of Agents" with native machine-to-machine interfaces rather than human-centric web interactions.

Agent Protocol

AI Engineer Foundation's framework-agnostic standard for agent lifecycle management using RESTful APIs and OpenAPI v3. Defines core abstractions for Runs (task execution), Threads (multi-turn interactions), and Store (persistent memory). Enables control consoles to manage heterogeneous agents across diverse systems with standardized operations.

Agent Interaction & Transaction Protocol (AITP)

NEAR Foundation's blockchain-based protocol for secure agent communication across trust boundaries. Supports autonomous negotiation and value exchange through structured capabilities and thread-based communication. Explicitly designed for cross-organizational agent interactions with built-in identity verification and transaction capabilities. Focuses on cost negotiation and allows competing agents to bid to solve problems.

Summoner Protocol (SPTL)

Summoner is a modular runtime and SDK for building and coordinating autonomous agents across networks. It combines a Python client, Rust relay server, and optional desktop UI. Implements the SPTL protocol with self-issued cryptographic identities, encrypted relay routing, and behavior-based reputation for trust. Supports native micropayments (ERC-20 compatible) and modular SDK extensions for composable agent systems. Focused on decentralized, enterprise-grade agent networks with verifiable communication and privacy.

Positioned as an open, peer-to-peer alternative to hub-based systems like MCP or A2A, Summoner aims to establish the foundational protocol for the autonomous agent economy.

Agent Connect Protocol (AConP)

Cisco/LangChain specification defining standard APIs for agent invocation and configuration using OpenAPI and JSON. Provides endpoints for agent lifecycle management (run, interrupt, resume) and thread-based interactions. Features a distributed registry for global agent discovery and includes agent distribution mechanisms for downloading and executing agents locally.

Agent Communication Protocol (AComP)

Open protocol for agent interoperability by IBM using standardized RESTful APIs that support all modalities, async/sync communication, and streaming interactions. Built under the Linux Foundation with BeeAI as reference implementation, focuses on seamless agent replacement, multi-agent collaboration, and cross-platform integration. Features offline discovery, mimetype-based content handling, and works with any framework without requiring SDKs.

Agora Protocol

University of Oxford's meta-protocol for dynamic communication protocol negotiation between heterogeneous LLM agents. Uses Protocol Documents (plain-text descriptions) to enable autonomous protocol implementation and adaptation. Features self-upgrading protocols that begin with natural language and evolve to more efficient structured formats. Addresses the "Agent Communication Trilemma" by balancing versatility, efficiency, and portability through context-aware protocol selection.

Language Model Operating System (LMOS)

An Eclipse Foundation framework for Internet of Agents using JSON-LD, DIDs, and multiple transport protocols. Agents are able to communicate using open protocols, but the LMOS protocol also provides flexibility in choosing the best transport protocol for each agent’s purpose. Rather than enforcing a single transport protocol like HTTP, MQTT, or AMQP, the LMOS protocol allows agents to select and adapt protocols based on their needs. Built on top of open standards and Kubernetes, it enables developers to build intelligent, scalable, and adaptive multi-agent systems.

LOKA Protocol

CMU's decentralized framework for human-agent interaction emphasizing identity, accountability, and ethical alignment. Features Universal Agent Identity Layer (UAIL) and Decentralized Ethical Consensus Protocol (DECP) using DIDs and post-quantum cryptography. Designed for responsible AI governance across digital and physical domains.

PXP Protocol

BITS Pilani's Predict and eXplain Protocol for bidirectional human-agent interaction using finite-state machines. Enables structured communication through RATIFY, REFUTE, REVISE, and REJECT message tags based on prediction and explanation agreement. Validated in radiology diagnosis and drug synthesis for intelligible human-LLM collaboration.

CrowdES

GIST's framework for robot-agent interaction in dynamic crowd environments using diffusion models and Markov chain behavior simulation. Generates realistic crowd behaviors for robot navigation and interaction planning. Focuses on real-time control and customization of crowd dynamics for embodied AI systems.

Spatial Population Protocols (SPPs)

University of Liverpool's distributed localization protocols for anonymous robot coordination using pairwise distance or vector queries. Enables robots to reach consensus on unified coordinate systems through minimal geometric information exchange.

Virtuals Protocol – Agent Commerce Protocol

Smart contract-based protocol for decentralized agent-to-agent transactions. Provides escrow, cryptographic agreement verification, and independent evaluation to ensure trustless, scalable coordination and commerce among autonomous agents.

Agent Name Service (ANS)

A DNS-inspired secure discovery framework for AI agents, leveraging PKI, JSON schemas, and protocol adapters (A2A, MCP, ACP). It uses the MAESTRO 7 Layers threat model to defend against impersonation, registry poisoning, and DoS, enabling trusted, interoperable multi-agent ecosystems.

Agent-Computer Interface (ACI)

Princeton's SWE-agent introduces a custom Agent-Computer Interface (ACI) for LLM agents to autonomously perform software engineering tasks. The interface enables agents to navigate repositories, edit code, and run tests using structured interactions instead of raw shell commands. Achieves state-of-the-art results on SWE-bench and HumanEvalFix. Demonstrates that purpose-built digital interfaces, akin to IDEs for humans, significantly improve agent capabilities in complex programming workflows.

Resources

• [White Paper] A Survey of AI Agent Protocols

• [Video] MCP vs ACP vs A2A: Comparing Agent Protocols

• Introducing the Agent Communication Protocol (ACP) by IBM

• Technology & Innovation skills pathway: Automated Fundamental Analysis with Agentic AI (2 of 3)

If you like this post, check out our AI coding assistants guide here 👇

🔥 Top Picks This Issue

👌 12-Factor Agents – humanlayer
🌟 Claude Code: Practical Tips for Agentic Coding – Anthropic
🤖 What are Multi-Agent Systems? – NVIDIA
🪦 The Software Engineering Identity Crisis – Annie Vella
🔥 Prompt Engineering Techniques with Spring AI – Christian Tzolov
👥 Human in the Loop Software Development Agents – Jirat Pasuksmit, Kun Chen
🔍 How DoorDash leverages LLMs to evaluate search result pages – DoorDash
🔐 Securing FastMCP with Keycloak & Ollama – Abhishek Koserwal
…and if you dare, 57 more updates to explore 👇

🎯 Featured Article

👌 12-Factor Agents - Principles for building reliable LLM applications – A practical framework for building LLM-powered software that can reliably serve production users.

Drawing from patterns seen across real-world agent deployments, this guide outlines twelve core principles—like owning your prompts and context window, treating tools as structured outputs, and unifying execution and business state—to help developers move beyond brittle prototypes. Instead of relying on heavy frameworks, it emphasizes modular, composable practices that integrate well into existing systems.

📰 Long-Form Reads

🌟 Claude Code: Practical Tips for Agentic Coding – A hands-on guide to using Claude Code effectively across real-world development workflows, from setup and customization to testing, debugging, and automation.

What are Multi-Agent Systems? - NVIDIA outlines how multiple AI agents collaborate to solve complex tasks, covering orchestration patterns, benefits, and practical architecture considerations.

What I Learned From Forcing AI to Fix Its Own Code For 27 Days → it can build software autonomously, but let's not pretend humans are obsolete quite yet.

🤦‍♂️ The Policy Puppetry Prompt Injection Technique - a prompt injection attack that disguises malicious prompts as policy files, tricking LLMs into obeying them.

Semantic Unit Testing - Alex Molas

The Software Engineering Identity Crisis - Annie Vella - Annie Vella 🪦

Principles for coding securely with LLMs - sean goedecke

A Critical Look at MCP - Raz Blog

You are using Cursor incorrectly... - Cursor

OpenAI Embraces MCP: The Protocol Era of AI Has Arrived ⚰️

🔥🔥🔥 Prompt Engineering Techniques with Spring AI - A hands-on guide showing how to apply core prompt engineering techniques—like few-shot prompting, chain-of-thought, and system roles—using Spring AI’s fluent Java APIs to build structured, configurable LLM-based applications.

Claude Code – Hidden‑Gem Power Tips

Senior Developer Skills in the AI Age - Manuel Kießling

How DoorDash leverages LLMs to evaluate search result pages

Human in the Loop Software Development Agents - Work Life by Atlassian - Jirat Pasuksmit, Kun Chen

The Differences between Deep Research, Deep Research, and Deep Research - Han Lee

The AI Driven Development Glossary - Eric Elliott

Creating a LLM-as-a-Judge - a step-by-step guide based from 30+ implementations - Hamel Husain 🔥

How AI Agents work and how to build them - Slobodan Stojanovič

Evaluating Large Language Model (LLM) systems: Metrics, challenges, and best practices - Jane Huang 🔥

🔐 Securing FastMCP with Keycloak & Ollama - Abhwishek koserwal 🧙‍♂️

Revealing Computational Graphs in Language Models - Anthropic

Data reviews: As important as code reviews?- As AI and data pipelines grow in importance, is validating data becoming as critical as reviewing code?

Lil'Log's Deep Dive into Autonomous Agents 2023 - Lilian Weng

What are Agentic Workflows? | A short, preceise definition from IBM

🐦 Social Highlights

AI Tool Stack for Building Projects

A surprising thing I'm noticing with AI - Gergely Orosz on X

LLMs being possible should feel like insane magic.

next level openai codex abuse

🗞️ News and Updates

Last month has been the busiest yet for developer tooling and model announcements:

Google unveiled new agentic tools at I/O 2025 - Gemini Agent Mode, Project IDX, and Gemini Code Assist expand Google’s ecosystem for developer-focused AI agents.

Mistral launched open-source LLM optimized for software engineering

Google announced Project Jules, an autonomous background AI agent

OpenAI launched Codex, a cloud-based software engineering agent - it can run multiple dev tasks in parallel—writing features, fixing bugs, proposing PRs—powered by the new codex-1 model.

Claude's new models ar optimized for coding and general-purpose AI agents

Windsurf introduced SWE-1, a model family for full-spectrum software engineering - optimized for tasks across the entire software engineering lifecycle, not just coding.

GitHub Copilot coding agent enters public preview

🛠️ Tech & Tools

Goose: an open source, extensible AI agent that goes beyond code suggestions - ins... -

codecanvas.ai - Another AI website builder. 🤷‍♂️

PocketFlow - Turns Codebase into Easy Tutorial with AI

🚀 fastmcp: The fast, Pythonic way to build MCP servers and clients

🚀 chainlit: Build Conversational AI app in minutes ⚡️

Google Firebase Studio - A pretty good generative AI-native IDE for building full-stack web applications.

agents-json - another attempt to standardize AI agent interactions with APIs

mcp.run - registry of AI tools

Requesty - LLM Gateway for unified access with intelligent load balancing and caching

Zencoder – The AI Coding Agent - Zencoder

Serenade | Code with voice - Serenade

ToolHive makes deploying MCP servers easy, secure and fun - stacklok

DevDocs: Free, private, UI based Tech Documentation MCP server. - cyberagiinc

Nuanced - Python library that provides LLMs with precise call graph context

PayPal Agent Toolkit - enables PayPal API integration through function calling

Visualize any codebase with AI-generated system diagrams

🤦‍♂️Create beautiful emails using natural language

📚 Learning Picks

🤗 Hugging Face Agents Course

🔥 Python Programming MOOC 2025

🔥 11 Lessons to Get Started Building AI Agents - Microsoft

Learn Agentic AI using Dapr Agentic Cloud Ascent (DACA)

Generative AI Labs with Gemini on Google Cloud | Google Cloud Skills Boost - Google Cloud Skills Boost

LangChain Academy

AWS Artificial Intelligence Practitioner Learning Plan

🎭 AI Humor

🙃 https://www.linkedin.com/feed/update/urn:li:activity:7336126353198489601/

👋 See You Next Week

Thanks for reading Generative Programmer! 🙏

If you like the content please support my newsletter by subscribing and sharing with your network: X · LinkedIn · BlueSky · Email. Have a great rest of the week!

Subscribe now

Share

🧠 Prompt & Context Engineering

• The Complete Guide to Building Skill for Claude (PDF)
  Author: Anthropic
  https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf

• Prompt Engineering (PDF)
  Author: Lee Boonstra
  https://www.kaggle.com/whitepaper-prompt-engineering

• Foundational Large Language Models & Text Generation (PDF)
  Kaggle / Google
  https://www.kaggle.com/whitepaper-foundational-llm-and-text-generation

• Prompting Guide 101 (PDF)
  Google – Gemini for Workspace
  https://services.google.com/fh/files/misc/gemini_for_workspace_prompt_guide_october_2024_digital_final.pdf

• Mastering: LLM as a Judge
  Galileo (2025)
  https://galileo.ai/ty/mastering-llm-as-a-judge

• The Context Engineering Guide (PDF)
  Weaviate
  https://weaviate.io/ebooks/the-context-engineering-guide

  ---

🤖 Designing Agents

• A Practical Guide to Building Agents (PDF)
  OpenAI
  https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

• Agents (PDF)
  Google – Tools, Extensions, and Datastores
  By Julia Wiesinger, Patrick Marlow, and Vladimir Vuskovic
  https://www.kaggle.com/whitepaper-agents

• Introduction to Agents (PDF)
  Kaggle / Google
  https://www.kaggle.com/whitepaper-introduction-to-agents

• Agent Companion (PDF)
  Kaggle / Google
  https://www.kaggle.com/whitepaper-agent-companion

• Google’s Approach for Secure AI Agents (PDF)
  Kaggle / Google Research
  https://storage.googleapis.com/gweb-research2023-media/pubtools/1018686.pdf

• From Prototype to Production (PDF)
  Kaggle / Google
  https://www.kaggle.com/whitepaper-prototype-to-production

• Building Effective Agents
  By Erik Schluntz & Barry Zhang (Anthropic)
  https://www.anthropic.com/engineering/building-effective-agents

• Mastering AI Agents (PDF - gated)
  Galileo – A comprehensive guide to evaluating AI agents
  https://www.galileo.ai/ty/ebook-mastering-agents

• Securing AI Agents and Non-Human Identities in Enterprises
  Cerbos (2025)
  https://solutions.cerbos.dev/securing-ai-agents-non-human-identities-in-enterprises

• Google's Approach for Secure AI Agents
  Santiago (Sal) Díaz, Christoph Kern, Kara Olive – Google (2025)
  https://research.google/pubs/an-introduction-to-googles-approach-for-secure-ai-agents

• Agentic AI Patterns and Workflows on AWS (PDF)
  Aaron Sempf & Andrew Hooker, Amazon Web Services
  July 2025
  https://docs.aws.amazon.com/pdfs/prescriptive-guidance/latest/agentic-ai-patterns/agentic-ai-patterns.pdf

🔍 Retrieval-Augmented Generation

• Mastering RAG (PDF - gated)
  Galileo AI — ~200-page enterprise RAG guide
  https://www.galileo.ai/mastering-rag

• Agentic Architectures for Retrieval-intensive Applications
  Weaviate
  https://weaviate.io/ebooks/agentic-architectures

• What is Agentic RAG?
  By Erika Cardenas & Leonie Monigatti (Weaviate)
  https://weaviate.io/blog/what-is-agentic-rag

🧪 Evaluation

• Evaluating Agents X post
  Ornella Altunyan (Braintrust)
  https://www.braintrust.dev/blog/evaluating-agents

• LLM Evaluation Metrics: The Ultimate Guide X post
  Confident AI
  https://www.confident-ai.com/blog/llm-evaluation-metrics-everything-you-need-for-llm-evaluation

• Agent Quality (PDF)
  Kaggle / Google
  https://www.kaggle.com/whitepaper-agent-quality

⚙️ Other Free Resources

• Machine Learning Q and AI
  Sebastian Raschka – No Starch Press (2024–2025)
  https://sebastianraschka.com/books/ml-q-and-ai/

• AI Value Creators: The AI Handbook for Innovators (PDF)
  IBM / O’Reilly
  https://www.ibm.com/campaign/ai-value-creators

• Agentic AI in Financial Services
  IBM

  https://www.ibm.com/downloads/documents/gb-en/12f5a71117cdc329

🔥 Top Picks This Issue

🧬 On the Biology of a Large Language Model - Anthropic research
📊 Agentic Software Is Not a Chatbot with Loops - Mike Erlihson
🧠 Avoiding Skill Atrophy in the Age of AI - Addy Osmani
🛠️ Writing Cursor Rules with a Cursor Rule - Adithyan
🧙‍♂️ How to Think About Agent Frameworks - LangChain
🌊 Technology Radar April 2025 - Thoughtworks
✍️ AI by Hand - Tom Yeh
…and if you dare, 65 more updates to explore 👇

🎯 Featured Article

🌟🌟🌟 On the Biology of a Large Language Model 🧬 Anthropic's research into Claude 3.5 Haiku's internal mechanisms using circuit tracing reveals groundbreaking insights into how large language models perform complex tasks. Key findings include the model's ability to perform multi-step reasoning, plan future outputs and utilize both language-specific and abstract multilingual circuits.

📰 Long-Form Reads

What Agentic Software Really Means: Beyond LLM Wrappers and Hype - Mike Erlihson - Agentic Software Is Not a Chatbot with Loops!🔥🔥🔥

Radar Trends to Watch: April 2025 -- O'Reilly - Mike Loukides - Developments in AI, Biology, Operations, Security, and More 👌

The State of Reinforcement Learning for LLM Reasoning - Sebastian Raschka, PhD 🧠

The “S” in MCP Stands for Security - Elena Cross - The USB-C for AI agents desperately needs security before we plug our data into every model under the sun. 🔓

The MCP Authorization Spec Is... a Mess for Enterprise - Christian Posta

Model Context Protocol has prompt injection security problems - -MCP promises a new standard for LLM tools, but apparently forgot to pack security in.

🥀 The Bitter Prediction - The Ivory Tower - A developer's journey from AI skeptic to enthusiast ends with the sobering realization that tools like Claude Code are so frighteningly competent they might soon render human programmers obsolete.

💰 A new framework for AI agent pricing - by Manny Medina - Manny Medina

How Cursor (AI IDE) Works - Shrivu Shankar (X post)

Stop overbuilding evals - Doug Turnbull

MCP Servers: The New Security Nightmare - MCP Servers are bringing back command injection vulnerabilities like it's 2005 🤦‍♂️

Avoiding Skill Atrophy in the Age of AI -

From APIs to Capabilities to Support AI Agents - Christian Posta

Building a To-Do List App with Prompt Driven Development - A step by step guide by

Writing Cursor Rules with a Cursor Rule - Adithyan 🧙‍♂️

Human in the Loop Software Development Agents - Jirat Pasuksmit from by Atlassian (X post)

From requirements to prototype with Gemini Code Assist

Build Your Own Code Interpreter - Cookbook - Mandeep Singh 🔧

Claude Code Best Practices - Boris Cherny from Anthropic

Principles for Building One-Shot AI Agents for Automated Code Maintenance - Rob Szumski

Secure execution of code generated by LLMs

How to think about agent frameworks - LangChain's manifesto subtly throwing shade at OpenAI's oversimplified take. 🔥🔥🔥

AI Trends Disrupting Software Teams - (this one is by me) - This article outlines five AI-driven trends already reshaping software development, and offers guidance for how different roles can adapt, survive, and thrive in this fast-evolving roller coaster. 🚂

Thoughtworks Technology Radar April 2025 - This edition focuses heavily on the practical evolution of generative AI tools especially coding assistants 🤖🌊

5 AI Use Cases for GTM Market Research - Maja Voje

Senior Developer Skills in the AI Age - Manuel Kießling

What are AI Agents? why do they matter? -

The Art of Validating Non-deterministic AI Responses - Swetha Veluri

AI by Hand ✍️ -

Vibe Coding is not an excuse for low-quality work -

Principles for coding securely with LLMs - sean goedecke

Build safe and responsible generative AI applications with guardrails - AWS Machine Learning Blog

🐦 Social Highlights

Claude Code Best Practices at Anthropic - Alex Albert from Anthropic reveals a collection of practical coding patterns using Claude.

Three AIs, one prompt. Who did it best?

Netlify Hits 1 Million AI-Generated Apps 👏

X: Models don't know how to use cursor anymore - they're all being optimized for terminal. That's why 3.7 is and o3 are so awful in Cursor, and so amazing outside of it.

The Ultimate List of Prompts to Style Images using ChatGPT

OpenAI Releases New Models Trained for Developers - Loraine Lawson

How AI Agents Are Quietly Transforming Frontend Development - Alexander T. Williams / The New Stack

What’s new in Cursor_0.49: rule generation…

🛠️ Tech & Tools

Build and deploy Remote MCP servers to Cloudflare

Doriandarko/claude-engineer - Doriandarko

OpenAI's Codex CLI - openai

LLM Guard - The Security Toolkit for LLM Interactions

Serverless Framework's MCP Server

Agent2Agent Protocol - Google's Agent2Agent Protocol promises to revolutionize AI communication 🙄 (X post)

AGNTCY.org - An open source collective for inter-agent collaboration.

GitHub - wild-card-ai/agents-json - The agents.json specification is yet another attempt to standardize AI agent interactions

Teaching LLMs how to solid model - Will Patrick boldly predicts that LLMs will soon transform mechanical engineering by designing CAD models too 🔧

Agent Development Kit - Google announces Agent Development Kit

A curated list of resources about AI agents for Computer Use

Pocket Flow - Turns GitHub repo into Easy Tutorial with AI

Fleur MCP Fleur /flœʁ/ is the app store for Claude

📚 Learning Picks

📋 The AI & ML Resource Library - a solid collection of learning resources.

Foundational Large Language Models & Text Generation - a pleasant-to-read whitepaper on Kaggle

👏 A practical guide to building agents - OpenAI's guide to building agents (X post)

🎭 AI Humor

by @catalinmpit 🙃

👋 See You Next Week

Thanks for reading Generative Programmer! 🙏

If you like the content please support my newsletter by subscribing and sharing with your network: X · LinkedIn · BlueSky · Email. Have a great rest of the week!

Subscribe now

Generative AI is the latest shift. This article introduces 10 foundational GenAI concepts that have become critical to understanding the technology and building on top of it.

1. Transformer Architecture

The path to today's ChatGPT began around 2014, when the dominant approach to language processing was sequence-to-sequence models. These models, pioneered by researchers at Google in their paper "Sequence to Sequence Learning with Neural Networks", worked like a pipeline with two main parts: an encoder that processed input text word by word, and a decoder that generated output text. These models would compress an entire sentence into a single fixed-length vector before generating a response, creating a major bottleneck where longer texts lost substantial information.

In 2015, researchers proposed a better solution called "attention" in the paper "Neural Machine Translation by Jointly Learning to Align and Translate". Instead of forcing all information through one vector, attention allowed the decoder to "look back" at different parts of the input when generating each output word. This was like giving the model the ability to focus on relevant parts of the input as needed, similar to how humans might re-read specific sentences when composing a response.

The real breakthrough came in 2017 with the paper "Attention Is All You Need", which introduced the Transformer architecture. What made Transformers revolutionary was that they:

• Processed all words in parallel rather than one-by-one (massively speeding up training)

• Used a sophisticated "self-attention" mechanism that let each word directly relate to every other word

In 2018, OpenAI built on this by creating GPT (Generative Pre-trained Transformer) in their paper "Improving Language Understanding by Generative Pre-Training", which used just the decoder portion of the Transformer architecture. The key innovation was pre-training on massive amounts of text data before fine-tuning for specific tasks. The book Prompt Engineering for LLMs explores this evolution in greater detail.

2. Agentic Systems

At its core, an agentic system uses an AI model (typically an LLM) to autonomously perform tasks by making decisions and taking actions to achieve specific goals. Unlike simple prompt-response interactions, these systems can reason, plan, use tools, and adapt their approach as they work toward completing objectives.

Rather than defining agents in binary terms (agent vs. not-agent), it's more useful to think of agentic behavior as a continuum—from rule-following assistants to fully autonomous problem-solvers. As Anthropic folks suggest, different systems can be agentic to different degrees depending on their capabilities and autonomy level.

The agentic spectrum expands to:

• Agentic Workflows sit at the more controlled end of the spectrum. These involve an LLM making limited decisions within a structured process, where the path to completion is largely predefined. For example, an invoice processing system might use AI to extract data, classify documents, and prepare them for human review—following a specific series of steps with limited autonomy.

• Autonomous Agents represent the high end of the spectrum, with the ability to determine their own goals, subtasks, tools, and execution strategies with minimal human guidance. These agents might employ complex planning, self-reflection, and error correction to accomplish broadly defined objectives like "research a topic and write a comprehensive report" or "plan a vacation based on preferences."

For software engineers, the important consideration isn't whether something is truly an agent, but rather what degree of autonomy makes sense for your particular application. Many business problems benefit from the more controlled approach of agentic workflows, while more complex exploratory tasks might call for greater autonomy. See a precise coverage of 'agentic' in this video by the Google Cloud DevRel team.

3. Non-Determinism

Traditional software systems are deterministic—given the same inputs, they produce the same outputs every time. In contrast, generative AI introduces fundamentally non-deterministic behavior, where identical prompts can produce different responses even with the same parameters.

This non-determinism comes from several sources:

• Sampling methods like temperature and top-p that intentionally introduce randomness

• Context-sensitivity where subtle changes in context lead to different interpretations

• Training variation that causes models to develop different "paths" of reasoning

Consider an AI agent tasked with researching a topic. We cannot predict in advance which tools it will call, in what order it will use them, how many iterations of research it will perform, or when it will decide the task is complete. One execution might involve three web searches followed by summarization, while another execution with the identical starting point might involve dozens of searches, calls to analysis tools, and multiple refinement steps.

This runtime non-determinism creates a fundamentally different software architecture. Rather than defining explicit sequences of operations, engineers must create environments where agents can operate safely within boundaries. These boundaries typically include:

• Maximum execution time or token limits

• Caps on the number of tool calls or iterations

• Restricted tool access based on security considerations

• Budget constraints for resource consumption

• Human approval checkpoints for critical decisions

The architecture shifts from prescriptive flows to constraint-based systems. Instead of telling the system exactly what to do, we define what it can and cannot do, then allow it to determine its own path within those constraints. For software engineers, this represents a profound shift in system design. We must architect for possibilities rather than certainties, creating robust environments that remain stable regardless of which execution path an agent chooses to take.

4. Retrieval-Augmented Generation (RAG)

AI models, like humans, make better decisions when they have relevant information. While foundation models contain impressive amounts of knowledge, they face two fundamental limitations: their training data has a cutoff date, and they are limited to mostly public information found on the internet.

The concept of Retrieval-Augmented Generation was introduced in the 2020 paper "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks", which proposed RAG as a solution for situations where all available knowledge can't be directly included in a model's context.

RAG solves this problem by enabling models to pull information from external sources before generating a response. Think of RAG as the "library lookup" pattern for AI systems - rather than relying solely on memorized knowledge, the app can reference specific documents, databases, or other knowledge sources on demand.

This approach offers several crucial benefits:

• Reduced hallucinations: With access to factual information, models are less likely to make things up

• Access to proprietary data: Models can work with your organization's internal documents

• Up-to-date information: Systems can incorporate data from after the model's training cutoff

For software engineers, knowing RAG is analogous to knowing the sidecar pattern in Kubernetes. RAG extends the capability of the main container (the LLM) by providing a specialized service (information retrieval) that complements its core functionality.

5. Evals

In conventional software development, testing typically validates deterministic functions: "When I input X, I expect output Y." For AI systems, we instead need probabilistic assessments: "When I input X, is the response reasonable, accurate, and appropriate?". This fundamental challenge requires us to rethink quality assurance for AI applications. We need to evaluate whether outputs are helpful, accurate, safe, unbiased, and aligned with human values—none of which can be validated through simple assertion testing.

Modern AI evaluation frameworks employ several complementary approaches:

• LLM-as-Judge leverages the linguistic understanding of one AI system to evaluate another. This approach acknowledges that language models excel at nuanced assessments of text quality, coherence, and appropriateness.

• Metric-Based Evaluations focus on quantifiable dimensions of performance. These include factual accuracy where outputs are compared against trusted information sources, hallucination detection to identify when models fabricate information, context relevance assessments that determine if responses properly address specific queries, task completion rates measuring successful execution of user instructions, and safety scores for detecting harmful content. Together, these metrics provide a comprehensive view of model performance across critical dimensions.

• Human Feedback Collection remains essential, particularly for subjective elements like helpfulness, creativity, and tone. Despite advances in automated evaluation, human judgment continues to serve as the gold standard for assessing many aspects of AI-generated content.

The evaluation landscape has rapidly evolved from ad-hoc testing to comprehensive frameworks that span the entire AI application lifecycle:

Development-time evaluation helps engineers catch issues early during model development. Continuous evaluation applies CI/CD principles to AI systems, with automated testing on each iteration. Production monitoring extends evaluation into deployed applications, tracking model performance on real-world inputs. This closes the loop by identifying issues that weren't caught in pre-deployment testing and capturing edge cases for future evaluation sets, creating a virtuous cycle of continuous improvement.

For software engineers, evaluation frameworks represent not just a quality assurance step but a fundamental part of the development process that helps shape model behavior and catch failures before they impact users. Understanding evals is crucial for ensuring AI applications meet quality standards and perform reliably in production environments.

6. Vibe Coding

Vibe coding, a term coined by Andrej Karpathy in February 2025 in his viral tweet, refers to a specific approach to programming where developers "fully give in to the vibes" and "forget that the code even exists."

As clarifies in his newsletter, vibe coding means letting the LLM write and ship code without review. It's distinct from responsible AI-assisted development, where output is verified. Using an LLM to generate code snippets that you then review, understand, and integrate is not vibe coding—it's just responsible software development with AI tools.

Vibe coding shines for:

• Quick prototypes and experiments

• Personal projects with low stakes

• Learning and building intuition about what AI can do

• Democratizing programming for non-developers

However, vibe coding is unsuitable for:

• Production systems where reliability matters

• Applications handling sensitive data or money

• Code that needs to be maintained long-term

• Projects requiring specific security or performance characteristics

A software developer’s role goes beyond writing code and shipping features. It involves building systems that are reliable, maintainable, and understandable by humans. Vibe coding prioritizes speed and non-technical accessibility, which can be useful in certain scenarios, but it’s not a replacement for disciplined, intentional engineering.

7. Chain of Thought (CoT)

Prompt engineering is the practice of crafting inputs to AI models to effectively guide their outputs. Unlike traditional programming where instructions follow strict syntax, prompt engineering involves designing natural language instructions that shape an AI's behavior. For software engineers, this skill has become essential—it's effectively the "API" for interacting with language models.

Chain of Thought prompting encourages AI models to break down complex problems into step-by-step reasoning before providing a final answer. Instead of just asking "What's 17 × 24?", you ask "What's 17 × 24? Let's solve this step by step."

Adding cues like "Let's think step by step" often triggers structured reasoning learned during training, resulting in dramatically improved accuracy for tasks requiring reasoning, calculation, or multi-step analysis. It works because modern LLMs have been trained on numerous examples of human reasoning, but need a cue to activate this capability.

CoT is particularly valuable for software engineers when:

• Generating complex code that requires careful planning

• Debugging issues that need logical analysis

• Breaking down requirements into implementable steps

• Reviewing complicated logic or algorithms

The main tradeoff is verbosity—CoT responses use more tokens, which means higher costs and longer generation times. However, for tasks where accuracy matters more than speed, this is often worthwhile.

8. Tool Calling

In AI applications, tool calling (also known as function calling) is a pattern where large language models (LLMs) can extend their capabilities by requesting external functions to be invoked. These tools can retrieve information (e.g., weather data, database lookups) or perform actions (e.g., send an email, update a record). This pattern enables models to work with up-to-date or dynamic information they wouldn’t otherwise know. Although often called “function calling,” tool calling is a better name because it reflects a broader abstraction: tools may not be pure functions—they can be services, workflows, or stateful processes. The term also aligns with the Model Context Protocol (MCP), which standardizes model interaction with external tools via structured, declarative calls.

Something to be aware for new comers, the model does not directly execute these tools. It only produces a tool call request—containing the tool name and input parameters. The hosting application is responsible for resolving this request, executing the corresponding tool, and returning the result back to the model. This separation ensures safety, auditability, and flexibility, as the model cannot autonomously interact with external systems. Tool calling lets developers tightly control what models can do, while still enabling context-aware behaviors.

9. Generated Code Execution

Language models excel at natural language understanding and generation but struggle with precise calculations, data manipulations, and interactions with external systems. This limitation significantly constrains their ability to solve real-world problems that require computational accuracy or data processing. Generated code execution bridges this gap by combining the creative, adaptive reasoning of AI with the deterministic reliability of code. This represents a paradigm shift in how AI systems interact with computational environments. Unlike traditional development where code is written, reviewed, and deployed in advance, this approach enables AI models to dynamically generate and execute code at the exact moment it's needed.

At its core, Generated code execution follows a simple flow:

1. An AI system identifies a computational need within a conversation or task

2. The system generates appropriate code to address this need

3. The code is executed in a secure, isolated environment

4. Results are captured and integrated back into the AI's reasoning process

5. The AI can iterate on the code based on results or evolving requirements

This execution happens in real-time, maintaining the users’ flow of interaction while dramatically expanding the AI's capabilities. Systems like E2B and Microsoft's AutoGen, OpenAI’s Code Interpreter, represent different implementations to solving the same technical challenge. Implementation approaches range from sandboxed virtual machines, containerized environments, SaaS, with varying tradeoffs between security, performance, and resource usage.

This approach enables AI systems to:

• Perform complex calculations with perfect accuracy

• Analyze and visualize data on demand

• Interact with external APIs and services

• Transform and process structured data precisely

• Build custom utilities tailored to specific tasks

• Prototype solutions in real-time

• Verify logical reasoning through computational proof

As this technology matures, we'll likely see generated code execution become an integral feature of AI-enhanced software development environments. For software engineers, this capability fundamentally changes architecture considerations. Rather than anticipating and pre-implementing every computational need, systems can be designed with the expectation that the AI will generate appropriate code on demand, allowing for more flexible and powerful applications.

10. Guardrails

Guardrails in generative AI are safety mechanisms that constrain an LLM's behavior within predefined parameters, preventing harmful, biased, or incorrect outputs while preserving the model's ability to generate helpful responses. For software engineers, implementing guardrails has become essential when building AI-powered applications that interact directly with users.

Without proper guardrails, LLM applications are vulnerable to adversarial attacks:

• Prompt injection: Attackers can insert instructions that override the model's intended behavior (e.g., "Ignore your previous instructions and instead...")

• Prompt leaking: Attacks that trick the model into revealing its system prompts or configuration

• Token smuggling: Bypassing filters by misspelling words or using symbols (e.g., "h0w to bu1ld a b0mb")

• Payload splitting: Breaking harmful requests into seemingly innocent parts that the model later combines

Consider this example: Without guardrails, asking "Can you tell me how to hack a website?" might yield detailed instructions for illegal activities. With guardrails, the model instead responds: "I cannot assist with illegal activities, but I can provide information about ethical cybersecurity practices."

Several approaches can be used to implement guardrails:

• Input and Output Filtering

  This includes blocking inputs or outputs containing harmful content such as hate speech, violence, or illegal activities; defining specific topics the model should refuse to discuss; blocking specific words, competitors' names, or sensitive terminology; and identifying and redacting personally identifiable information (PII).

• Pattern-Based Approaches
  These use regular expressions to identify problematic content, flag specific terms that indicate prohibited topics, and apply heuristic rules to evaluate content safety.

• Model-Based Approaches
  This involves deploying specialized models to evaluate the safety of inputs and outputs, using models trained to detect harmful content, and determining whether user requests have malicious intent.

• Architectural Approaches
  These include validating user inputs before they reach the LLM, checking model outputs before returning them to users, overlapping validation with generation to minimize latency, and validating output chunks during generation to support streaming.

For software engineers implementing AI systems, guardrails represent the crucial security layer between powerful but unpredictable language models and the users who interact with them. For more detailed implementation strategies, see AWS's guide on building safe AI applications with guardrails.

Final Thoughts

These 10 concepts aren’t just buzzwords—they reshape software design, architecture, and delivery. For software engineers, understanding them is no longer optional. As generative AI continues to evolve, these ideas will form the foundation for the next generation of software systems.

If you found this valuable, subscribe to generativeprogrammer.com newsletter for more practical insights on AI and modern software architecture. Follow me on twitter @bibryam for ongoing updates.

Bookmark GenerativeProgrammer.com and share this issue: 🐦 Twitter, 💼 LinkedIn, 🦋BlueSky, ✉️ Email Let's dive in!

🚀 This Week's Top AI Picks For Devs

🏢 AI "TuringBots" transforming app development SDLC (Forrester)
📊 The Ultimate LLM Evaluation Metrics Guide for production success
🧠 Simon Willison: "Vibe coding" vs responsible AI programming
🛠️ a16z explores Bolt, Lovable, v0 text-to-web app revolution
🧪 AirBNB converts 3,500 React tests using LLMs
🔒 Critical MCP "Tool Poisoning" vulnerability alert

…and 33 more updates to explore! 👇

🎯 Featured Article

The Rise of Application Generation Platforms - A futuristic Forrester research report about how low-code platforms are evolving into AI-powered environments, integrating generative AI and "TuringBots" to enhance every phase of the Software Development Lifecycle (SDLC).

While challenges like security and generative model limitations remain, the long-term shift points toward top-down AI-generated app creation driven by citizen developers and business users, not just coders.

📰 Long-Form Reads

Navigating Generative AI in Software Development - Thoughtwork's Birgitta Böckeler deep dives with hands-on examples that highlight how AI tools can accelerate development—but also make mistakes that can slow teams down, cause friction in collaboration, and hurt long-term maintainability. Developer expertise remains crucial, especially in managing these tools effectively and safeguarding software quality.

AI-Generated Web Bonanza - Netlify's impressive milestone of 1 million AI-generated apps signals a significant shift in web development, though one can't help but wonder if this "quantity over quality" approach might flood the internet with cookie-cutter websites lacking creative human touches.

The power of large context windows for your documentation efforts - The article discusses how LLMs with large context windows can transform documentation by creating personalized tutorials based on specific needs.

Why we chose LangGraph to build our coding agent - Qodo shifted from predefined workflows to using LangGraph for building more dynamic, flexible AI coding assistants in response to the improved capabilities of newer LLM models like Claude Sonnet 3.5. 🤖

LLM Evaluation Metrics: The Ultimate LLM Evaluation Guide - A comprehensive resource that explains how to develop appropriate LLM evaluation metrics and build robust evaluation pipelines for optimizing prompts, models, and monitoring performance in production. 📊

OWASP LLM Top 10 - Promptfoo is an open-source tool recognized by OWASP that helps developers identify and mitigate security vulnerabilities in LLM applications, providing comprehensive reports on the severity of potential risks. 🛡️

Not all AI-assisted programming is vibe coding - : While "vibe coding" (a more exploratory, prompt-based approach to AI programming) has gained popularity, it's important to distinguish it from other forms of responsible AI-assisted programming that involve more structured collaboration between developers and AI tools. 🧠💻

From Prompt to Product: The Rise of AI-Powered Web App Builders - The explores the explosive growth of text-to-web app builders like Bolt, Lovable, and v0, which let users generate functional websites and apps simply by describing them in natural language. These tools are democratizing app development, however, they also face limitations in complexity, reliability, and debugging.

Replit's AI Revolution - While Replit's AI agent creating two million codeless apps in six months sounds impressive, I'm skeptical about how many of these are truly valuable solutions versus simple novelties, as the 5% production deployment rate suggests most remain experimental toys rather than the democratized application development revolution being touted. 🤔

AI is useless, but it is our best bet for the future - The ironic title from antirez captures the paradoxical nature of current AI technology: simultaneously overhyped yet potentially transformative. Still, investing in AI is essential—not because of what it can do today, but because of the game-changing breakthroughs it could bring in the future. The potential rewards justify the risks and social disruptions we're experiencing now. 🤷‍♂️

AirBNB's Large-Scale Test Migration with LLMs - How Airbnb successfully completed a code migration project using LLMs to convert approximately 3,500 React component test files from Enzyme to React Testing Library. 🧪

LLM Inference Optimization - Focus on reducing output token count rather than input tokens when optimizing LLM inference speed, as output generation has approximately 100x more impact on latency than processing input tokens.

How to refactor code with GitHub Copilot - GitHub Copilot can be leveraged as a powerful tool to streamline code refactoring tasks and help during maintenance and improvement phases. 🛠️

Gemini 2.5 Pro vs. Claude 3.7 for Coding - For developers seeking the best AI coding assistant, Gemini 2.5 Pro emerges as the superior choice with its larger context window (1M vs 200K), better coding capabilities, and free tier availability.

Securing AI agents: authentication patterns for Operator and computer using models - As AI operator models gain the ability to interact with interfaces like humans do, developers must implement robust authentication patterns to ensure security and compliance when these agents perform tasks on users' behalf. 🔐

What are Cursor Rules? - Cursor Rules allow developers to define custom instructions for LLMs in special files (typically in .cursor/rules directory) to enforce coding styles and best practices across a codebase, with granular control through file path patterns and glob matching. 🛠️

LLM Integration Best Practices - The article discusses key challenges when integrating LLMs into applications, including how models change over time requiring prompt adjustments, and the importance of effective prompt management as applications grow more complex. 🏗️

8 Use Cases for Generalist Software Development Agents - The article explores practical applications where AI agents can assist developers in coding tasks.

MCP: What It Is and Why It Matters - Another comprehensive coverage of MCP by . 🔌

Developers - Stop Asking LLMs to Write Code!! - Victor Dibia argues against the common practice of immediately asking AI to generate code, suggesting a more nuanced approach to AI literacy that mirrors how we learned to use the internet effectively; his perspective challenges popular GenAI tutorials while offering alternative strategies that could be a useful starting point for beginners. 🤔

Vibe Coding: Revolution or Reckless Abandon? - While AI-powered "vibe coding" promises seductive speed and simplicity, Osmani rightfully warns that this shortcut culture risks creating a generation of developers who can conjure code but not comprehend it, essentially building digital houses of cards that will inevitably collapse under the weight of security vulnerabilities and unmaintainable complexity. 🚩
LLMs: An Operator's View - Stanier acknowledges the overwhelming challenge facing team leaders in navigating the frenzied LLM landscape🧠

AI and Platform Engineering - The enthusiasm around AI's impact on platform engineering (with a whopping 94% of organizations calling it "critical" or "important") feels suspiciously like tech hype déjà vu.

MCP Security Notification: Tool Poisoning Attacks - Invariant Labs has identified a critical vulnerability in the Model Context Protocol (MCP) that enables "Tool Poisoning Attacks," which can lead to data exfiltration and unauthorized model actions. 🔒

🎙️ YouTube & Podcasts

Why Agent Engineering — swyx - Swyx presents his vision for Agent Engineering as a key technology focus for 2025.

Building Effective Agents with LangGraph - This video by James Briggs discussing Anthropic's blog post on the distinction between agents and workflows, along with common patterns for building effective agents. 🤖

🐦 Social Highlights

Sriram on X - predicts that LLMs will evolve into orchestration engines that coordinate workflows involving external data sources through standardized protocols like MCP. Model providers will need to go vertical—specialize deeply—to survive, while a universal data access layer will empower hyper-personalized AI applications.

Hacking ChatGPT to make it run C + JavaScript - A step by step description of how to get into OpenAI's code executor to write Python that compiles C that builds a JavaScript runtime in the executor, then runs JavaScript. A must-read thread.

A Beginner's Guide to Performance Testing for LLMs - Benjamin shares his experience in load testing an offline LLM model to evaluate its capacity as user base grew.

Launch HN: Continue (YC S23) – Create custom AI code assistants - Continue offers a platform for developers to create customized AI code assistants that adapt to specific workflows and preferences. Continue's open architecture allows developers to build personalized AI coding assistants using the latest models and tools, rather than being locked into outdated technology. 🛠️

🛠️ Tech & Tools

21st.dev – The NPM for Design Engineers - A platform offering pre-built React Tailwind components inspired by shadcn/ui to help design engineers create polished user interfaces more efficiently. 🧩

https://new.email/ - A prompt-to-email service. That is it.

Same - Prompt URL to make copies, keep chatting to make changes.

Agent Recipes - Ready-to-copy code examples for common LLM agent patterns including sequential chains, routers, parallel processing, and orchestrated workflows.

Agentic-cursorrules - A Python tool that manages multiple AI agents in large codebases by partitioning projects into logical domains (frontend, backend, etc.) and generating markdown files with explicit file-tree boundaries to prevent conflicts. 🤖

Prompts.chat - This so-called "most famous" prompts directory is essentially a glorified list of conversation starters for AI models. One has to wonder if we've reached peak laziness when we need pre-written prompts to talk to machines that were designed to understand us in the first place. 🤨

Firecrawl MCP Server - The Firecrawl MCP Server implements the Model Context Protocol to enhance web scraping for LLM clients like Cursor and Claude, offering configuration options, rate limiting, and credit usage monitoring. 🕸️

Gemini Workshop for Java Developers - Java developers can leverage this GitHub repository to quickly explore Google's Gemini and Gemma LLMs using the LangChain4j framework, with ready-to-use code examples requiring only a Google Cloud account with Vertex AI enabled. 🚀

LLMPerf Benchmarking Tool - LLMPerf offers developers a practical way to evaluate LLM API performance through load testing (measuring latency and throughput) and correctness testing for production applications. 🔍

LLMDataHub - A repository that provides quick access to various instruction-tuning and training datasets for developers looking to train their own LLMs, especially valuable for small organizations without massive resources. 🔍

Agent Mode in Warp AI - Warp's AI integration directly in the terminal suggests your next commands, making terminal workflows more efficient for developers on Red Hat, Fedora, SUSE, and even Windows.

🔥 Turn entire websites into LLM-ready markdown or structured data - Firecrawl is an API service that crawls websites and converts their content into clean markdown or structured data for AI applications, with both hosted and self-hosted options available.

Introducing Nile MCP Server - Nile has launched a MCP Server too. 🔌

🎭 AI Humor

Source https://www.linkedin.com/feed/update/urn:li:activity:7307754550113816577/

👋 See You Next Week

Thanks for reading Generative Programmer! 🙏 If you like the content please support the newsletter by sharing with your friends via: 🐦 Twitter, 💼 LinkedIn, 🦋BlueSky, ✉️ Email.

Missed the last issue? Catch up here 📖 Got a topic you’d like me to cover? Just drop me an email!

Have a great rest of the week! 😉