Hey Friends 👋 Happy Wednesday

Here’s another weekly dose of AI ways of working.

Visual overview of the AI triage workflow and the two routing outcomes: new demand and operations.

I built an AI triage agent inside a regulated UK bank using Claude Code. It reads incoming Jira tickets, classifies them as new platform demand or operational work, writes its reasoning back into the ticket, and labels everything for automated routing. It runs against a real backlog. People on the team will act on what it produces.

This piece is really a case study. Not just on the build itself, but on what it looks like to use AI to solve a real operations problem in a regulated environment.

For founders and operators, that’s the part that matters. The opportunity is not in building flashy demos. It’s in creating operational efficiencies inside the workflows that already run your business.

The problem, and why it’s bigger than it looks

Before the methodology, the failures, or the architecture, the problem deserves more attention than most writeups give it. Without understanding why demand triage is genuinely hard, the build looks like a clever solution to a minor inconvenience. It isn’t.

Here’s what actually happens in most platform teams, central functions, and shared services at any organisation of meaningful size.

Demand arrives constantly. Some of it is operational, a broken service, a permissions issue, a configuration change on something that already exists. Fix it, close it, move on. Some of it is capability demand, a net-new workload, a new integration, a new environment that doesn’t exist yet. Design it, scope it, plan it, build it over weeks or months.

These are fundamentally different categories of work. They require different people, different processes, different timelines, and different conversations with leadership. Operations is about maintaining what exists. Capability is about building what doesn’t.

The problem is that they arrive through the same front door.

Every request, whether it takes a senior engineer three months to deliver or a junior engineer three hours, lands in the same Jira project. Someone has to read it and make a call. Is this keeping the lights on, or is this building something new?

That sounds like a simple question. It isn’t.

An access request for a new AWS account might be routine operations. Or it might be the first signal of a new workload that needs a full landing zone, a security review, and six months of platform design. A request to update firewall rules might be a two-line config change. Or it might be the start of a network architecture conversation nobody’s had yet. The summary rarely tells you which. The description is often missing entirely. The person who submitted it frequently doesn’t know the difference themselves.

So the decision falls to the people who do know, delivery managers, business analysts, senior architects. People whose time is expensive and whose judgement is built from years of platform context. They read the ticket, apply that judgement, and route it correctly.

Until they’re stretched. Until they’re on leave. Until three urgent things land at the same time and the backlog review gets pushed. Until the junior on the team picks up a ticket and makes a reasonable guess that turns out to be wrong — and a piece of strategic platform demand sits in the wrong queue for three weeks before anyone notices.

This is the failure mode. Not dramatic. Not a single incident. Just a slow, consistent bleed of misrouted work, missed priorities, and decisions that depended on the right person being available at exactly the right time.

At scale, across a portfolio of fifty or a hundred active tickets, this costs more than most organisations have ever tried to measure. Demand that should have been scoped six weeks ago. Operations work that consumed senior architect time. Strategic requests buried under routine noise.

The shared front door: a single intake form where operational requests and net-new platform demand arrive together.

The agent I built solves the classification problem. Every incoming ticket gets read, assessed against the platform’s actual context, active initiatives, existing patterns, routing rules, and classified before a human ever looks at it. The reasoning is attached directly to the ticket. The label is applied automatically. The humans who used to spend time making that call now spend their time on the cases the agent flags as genuinely ambiguous.

That’s a different way of working. And it’s repeatable across any team, in any sector, where demand arrives faster than the people responsible for routing it can keep up.

For founders, the same problem exists in your business. Support requests versus product feedback. Client issues versus new feature demand. Operational fixes versus strategic investment. If those categories are currently separated by whoever happens to read the email first, you have the same problem at a smaller scale. The solution is the same.

The operating architecture behind the build: ingestion, queueing, classification, Bedrock enrichment, storage, and Jira write-back.

The methodology before I wrote a single line of code

Most content about Claude Code covers short solo tasks. An afternoon project, a script, a quick component. The context window barely fills up, everything completes in one session, and the output is self-contained.

A build like this, even when done in under two weeks, is completely different. There’s existing context, decisions already made, work already in flight, conventions already established. And every Claude Code session starts cold. The model has no memory of what you did yesterday. You are the continuity. That’s the problem context management solves, and it’s the part nobody writes about because most people haven’t had to solve it yet.

Here’s how I structured it.

The context files. Before starting the build I identified three documents that held the most relevant organisational context: a conventions file covering how the team works and what standards apply; an initiatives register covering active work, status, and dependencies; and a patterns catalogue listing reusable components already built. These files didn’t exist for AI, they existed because the team already had good documentation discipline. They became the foundation of every session. Loaded at the start, refreshed when they changed.

If your business doesn’t have these files, creating them is the first step, not the Claude Code build. The agent is only as useful as the context it has to work with. For founders, that means documenting how your operations actually run before you try to automate them. That process alone will surface problems you didn’t know you had.

The 50–60% rule. I kept the context window at around 50–60% capacity throughout the build. The reason is simple: a model reasoning over a full context window has less room to work than one with space to think. When the window got heavy, accumulated output, long debugging threads, generated files, I started a new session and reloaded the context files. It felt inefficient. It wasn’t. The outputs were more consistent, and the model made fewer errors on the second half of a task than on the first half of an overloaded one.

Planning mode before execution mode. Before writing any code I ran a dedicated planning session using the most capable model available. I gave it the full brief: the problem, the constraints, the desired output, the platform context. What came back in a single session was a complete planning artefact set, user story with acceptance criteria, BDD scenarios covering the main classification cases, and architecture decision records for the key technical choices.

That output shaped every decision that followed. The acceptance criteria became my failure conditions. The ADRs became the record I could show the team. The scenarios became the test cases I ran the agent against. Two hours in planning mode before touching a line of code saved at least two days of rework. I won’t skip this step again.

The session handoff file. At the end of every working session I updated a short document, what was built, what came next, decisions made, open questions. This is what let me pick up the build the following evening without losing the thread.

Thirteen years of delivery management taught me that the handoff is where projects lose momentum. A decision made on Tuesday gets lost by Thursday if it isn’t written down. The same is true for AI-assisted builds, except the stakes are higher because the model has no continuity at all. You are the continuity. Write it down.

The agent running after the failures were fixed, Layer 1 firing deterministically, Bedrock being called for the ambiguous tickets, comments and labels written back to Jira. Getting here required fixing three separate problems first.

The failures

The first run didn’t work. Here’s exactly what happened.

Environment access took longer than expected. Before writing a single line of code I lost time to access issues — network permissions, credentials, tooling setup. In a regulated environment this is predictable. In any environment with real security controls, it’s possible.

Treat access setup as a project phase, not a prerequisite you can sort on the fly. Identify every system your agent will need to touch. Get the credentials and permissions sorted before you start building. Test connectivity before you assume it works. I didn’t, and it cost me a full day.

The data wasn’t in the format I expected. The first classification run failed immediately. Jira returns ticket descriptions as Atlassian Document Format — a deeply nested JSON structure, not readable text. The model was receiving something it couldn’t reason over. I had to build a recursive extractor to parse it and return clean text. Forty lines of code. Two hours to diagnose, twenty minutes to fix.

Real environments don’t give you clean inputs. Whatever your agent reads from — a CRM, a helpdesk, a form, assume the raw format will need processing before the model can use it. Build the extractor first, before the classification logic. Test it on real data before you test anything else.

The deterministic rules matched nothing. The fast filter I built — the layer that handled obvious cases without calling the AI, matched zero records on the first run. The rules checked for “New Feature.” The data said “new feature.” One character difference. I built a normaliser: strip punctuation, lowercase everything, handle common variations. Deterministic logic only works when you account for how humans actually enter data. They don’t use consistent casing. They abbreviate. They use different words for the same thing. Build the normaliser before you build the rules.

The architecture needed fixing mid-build. I had external dependencies threaded through the core logic in a way that would have caused problems in production. A more experienced engineer pointed me towards a cleaner pattern, separating the core classification logic from all external integrations so it could run identically in development and production.

I couldn’t have got there alone. What I had was enough of a relationship with the right person to ask the question, and enough technical understanding to know something was wrong. That’s the honest version of “ask for help”. It’s not about humility. It’s about knowing which gaps you have and closing them before you build yourself into a corner.

What the AI operator role actually requires

The AI operator role is a process role with technical capability built in. Not a technical role with some process knowledge bolted on. That distinction matters, and it’s why founders and operators are better positioned for this than most people currently claiming the title.

The AI operator role is a process role with technical capability built in.

But there are prerequisites nobody talks about honestly.

You need access to the actual problem. This build only happened because I had access to the environment, the data, and the people. I couldn’t have walked in cold and built it, the access came from relationships and trust built over two years before any of this started.

If you’re early in a role or a client relationship, your job right now isn’t to build AI tools. It’s to earn the access that makes building them possible. For founders, this is less of a barrier, you already have access to your own systems, your own data, your own team. That’s a genuine advantage. Use it.

You need at least one technical collaborator. I have enough technical understanding to design a system, read documentation, and know when something is wrong. I don’t have the vocabulary to know which architectural pattern to reach for when the structure needs fixing. Someone else did. Most content about AI operators assumes you’re working alone. The best builds I’ve seen involve at least one person who can catch what the operator misses. Find them before you start, not when you’re stuck.

You need to document what breaks. I wrote up the first run failing. I published it. Knowing I was going to write about what broke made me pay closer attention to why it broke, which is the only reason I know exactly what went wrong. If you’re not willing to document the failures alongside the wins, you’ll find reasons not to start. And you’ll learn less when you do.

You need to already understand the problem. I knew which problem was worth solving before I opened Claude Code. I knew what the output needed to look like. I knew the failure conditions. That knowledge came from years of working closely with operations teams and understanding how work actually flows. The tools are accessible. The understanding of which problem to solve, and what good looks like, is harder to acquire. That’s where your advantage sits, and it’s not something Claude Code can give you.

What I’d do differently

Sort access and credentials before the first session. This should be a completed prerequisite, not something you discover is broken on day one. List every system your agent touches. Get confirmation that each one is accessible from your build environment before you write anything.

Build a test environment and dry-run mode from the start. Run every early test against dummy data. Build the ability to classify without writing back to the real system before you run against anything real. I got away without this because I was working read-only. That was luck, not good practice. If your agent writes back to anything, a CRM, a helpdesk, a database, protect yourself from day one.

Trim the context passed to the model. I was loading the full documentation catalogue on every classification call. That’s expensive and slow. Pass only the slices relevant to the ticket. The more precisely you retrieve context, the cheaper and faster the system becomes.

Record every session from the start. The notes from the second week of this build were invaluable for writing this piece. The first week is largely gone. Start a running log on day one, even if it’s rough. You’ll use it.

If you want to build with AI over days, you need a handoff system. If you want to build over weeks, you need it even more.

The honest version of the opportunity

Building this gave me a glimpse of what operations could look like in the next few years. Not a prediction, a glimpse.

The core of good operations doesn’t change. Understanding how work flows, where it gets stuck, how to design a better state, and how to get people to trust it, that’s still the job. What changes is the execution layer. The tools available to act on that understanding just got significantly more powerful.

The founders and operators who identify the right problems, build the access and relationships to solve them, find their technical collaborators, and get their hands dirty. they’re the ones who will drive real efficiencies in their businesses.

That’s not a prediction about who survives. It’s an observation about what becomes possible.

I’m building more of these. I’ll keep sharing what I learn.

Hey Friends 👋 Happy Wednesday

Here’s another weekly dose of AI ways of working.

OpenAI shipped an official plugin on 30 March that lets you run Codex from inside Claude Code. If Claude Code is already where you plan, write, review and run work, you can now bring a second model into the same operating environment without changing tools.

I want to be precise about what follows. This dropped yesterday. I have not personally run every use case in this piece yet. This is what I can verify from the official announcement, the repository, and the early walkthroughs, translated for operators rather than developers.

Claude Code can do the build and planning pass. Codex can review, challenge, or take a second pass before you approve the work. If your Personal OS already lives in Claude Code, Codex becomes the quality layer on top.

What Codex actually is

Codex is OpenAI’s answer to Claude Code: an AI coding agent that can write code, understand unfamiliar codebases, review work, debug problems, and run development tasks against files and project context. For a non-coder, the useful translation is simpler. Claude Code is the builder. Codex is the critic. Codex is particularly strong where you want a second set of eyes on bugs, logic errors, edge cases, and design decisions before something goes live.

That difference matters because it gives you diversity in the review layer. These are competing systems built by different companies, trained differently, and likely catching different issues. One model produces the first pass. The other tries to break it. You stay as the approver.

How to set it up

The setup is straightforward once the prerequisites are in place. The biggest likely friction point for a non-technical operator is Node.js 18.18 or later. Open your terminal and type node --version. If you see a number below 18.18 or get an error, download Node.js from nodejs.org before continuing.

The official repository and the AlphaSignal walkthrough point to the same install flow. The Codex CLI is the local command-line tool the plugin relies on to run Codex tasks from your machine. If you do not already have Codex installed, the setup flow can offer to install it for you automatically when npm is available.

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex

Claude Code will ask where you want the plugin available: user, project, or local scope. If you are starting out, user scope is the simplest place to begin.

Then run:

/codex:setup

If you see an error after /codex:setup, run:

/reload-plugins

Then retry the setup command. If Codex is installed but not authenticated, run !codex login and sign in with your ChatGPT account. Once you see “Codex is ready”, you are set.

The three commands operators actually need

You do not need every command on day one. The three that matter most map cleanly to operator work.

There is also a review gate setting that can stop Claude Code from finishing before a Codex review runs. I would not start there because it can create long loops and burn through usage limits quickly.

What this looks like in practice for non-coders

Most of the early coverage is written for developers. The useful gap is the operator translation.

Proposal review. Claude Code drafts a proposal using your files, rules and business context. Before it goes to a client, you run /codex:review. Type /codex:review and Codex reads the current output and returns its findings; you do not need extra instruction for a standard review. This works best when your CLAUDE.md already holds your proposal rules and client context, because Codex is reviewing against a standard rather than guessing at one.

Lead analysis. You drop a CSV or client notes into the project folder. Claude Code analyses them against your criteria. Then you run /codex:adversarial-review to pressure-test the assumptions. This gets better when your lead criteria and business definitions are already captured in context.

Content audit. Claude Code reviews emails, posts or documents against your tone and brand rules. Codex then checks the output and flags where the logic slips or the tone drifts. Without your voice rules and brand constraints in place, both tools are still guessing.

Workflow QA. You build a reporting flow or internal operating task in Claude Code. Before it goes live, you run /codex:adversarial-review to look for edge cases. This is strongest when your folder structure already maps the workflow properly, so Codex is testing a system with context, not a one-off instruction.

How this fits a Personal OS

If your Personal OS already runs on folder structure, business context and clear rules, Codex fits as the review layer, not the replacement layer. Claude Code still does the planning and execution against your context. Codex comes in after that to give you a second opinion from a different model family.

If you do not have that operating layer yet, start there first. I have covered that transition in a previous guide, and I will link the broader Personal OS walkthrough here once it is published. The plugin is most useful once your rules, files and working standards already exist in context.

That is the management shift here. The old way was one person drafting, checking and QA’ing alone. The new way is you structuring context, delegating the first pass to one agent, the second pass to another, and keeping approval for yourself. The management skill did not change. The execution layer did.

What to watch out for

There are four caveats worth keeping in view. First, there are two accounts and two usage limits. Claude Code usage sits with Anthropic. Codex usage sits with your ChatGPT account or OpenAI API key.

Second, Node.js is the likely friction point for non-technical operators.

Third, the review gate is not a beginner setting. Treat it carefully until you understand the loop it creates.

Fourth, this is still day one. Test it first in low-stakes work before you rely on it for anything sensitive.

Closing

If you are setting this up, reply to this post and let me know what you used it for first. I am more interested in the operator use cases than the developer ones.

If you are not on the Personal OS journey yet, that is where this starts. The plugin is not the system. It is the review layer on top of one, and I will share the broader guide once it is live.

Subscribe below to get the next one when it drops.

References

[1] Introducing Codex Plugin for Claude Code - OpenAI Developer Community

[2] openai/codex-plugin-cc - GitHub

[3] You can now trigger Codex from Claude Code! Here’s how - AlphaSignal

[4] Codex | AI Coding Partner from OpenAI | OpenAI

[5] Codex | OpenAI Developers

Hey Friends 👋 Happy Thursday
Here’s another weekly dose of AI ways of working.

You have been sitting on a product idea for months.

You know exactly what it needs to do. You have mapped out the user journey, written the requirements, and identified the bottlenecks. But every time you think about building it, you hit the same wall: your time is better spent running the business than learning to code.

So you hire one. Or you try to explain your vision to a developer. Or you spend three hours in a ChatGPT rabbit hole and ship nothing.

Here is the thing nobody is telling you: the person who understands the problem is more valuable than the person who writes the code. That gap is now closed.

Garry Tan, the CEO of Y Combinator, the organisation that backed Airbnb, Stripe, and Coinbase, just open-sourced his personal Claude Code setup. He calls it gstack. According to Tan, in the past 60 days using this exact framework, he wrote over 600,000 lines of production code while running YC full-time (35% of which are tests). The repository accumulated over 33,000 stars on GitHub within a week of launch — one of the fastest-growing open-source repositories of 2026.

This is your new operator playbook.

Why Claude Code (Not ChatGPT)

Most operators start with ChatGPT. It is familiar. But there is a fundamental limitation: ChatGPT cannot act inside your operating environment. You feed it information, it generates text, and you copy-paste the result.

Claude Code is different. It operates directly inside your terminal, your operating environment, where all your context lives. It reads your files, runs your tests, and pushes your code. It does not wait for you to copy-paste anything.

The distinction matters. ChatGPT is a writing tool. Claude Code is an operating tool.

What gstack Actually Is

gstack is not a collection of prompts. It is a structured operating model, a sprint framework that forces you to move through a disciplined process before a single line of code is written.

The framework gives Claude Code a team of specialist roles and tools, each activated by a simple slash command. You are not writing software. You are managing a digital employee. That is what operators do.

The build cycle runs in a specific order. Each step feeds the next. Nothing falls through the cracks.

The /office-hours skill alone is worth the setup. It encodes how YC partners actually pressure-test startup ideas, the same questions they ask founders sitting across from them in Mountain View. You get that thinking applied to your idea before you spend a single hour building.

What You Will Build

You will build a structured operating process that transforms Claude Code from a blank prompt into a virtual engineering team.

•Time to set up: 5 minutes

•Time per build cycle: Under 30 minutes for a complete feature

•What you ship: Validated, tested, production-ready code

Step 1: Install gstack (5 Minutes)

What you need:

•Claude Code installed on your machine (download here)

•A terminal (Mac: Terminal or iTerm; Windows: PowerShell)

How to do it:

Step 1. Open your terminal.

Step 2. Run this single command:

git clone https://github.com/garrytan/gstack.git ~/.claude/skills/gstack && cd ~/.claude/skills/gstack && ./setup

Step 3. Restart Claude Code.

That is it. Claude Code now has access to all gstack specialist roles.

Operator Note: You are giving Claude Code a set of “skills.” Think of it as onboarding a new team of specialists on their first day. You are not writing code, you are setting up your operating environment.

Step 2: Run Your First Build Cycle

Open Claude Code and follow this process:

Adjust the cycle:

•For your first build, use “Hold Scope” mode in /plan-ceo-review to keep the scope tight.

•Replace the idea description in /office-hours with your specific business problem.

•Run /retro at the end of each week for an after-action review of what shipped.

Step 3: Review the Output

After /office-hours, you will receive a structured critique of your idea with three implementation alternatives. This is not generic AI output. The skill encodes the actual methodology YC partners use to evaluate startups.

Review the output. If the AI is pushing back on your framing, that is the point. A bad idea caught at the thinking stage costs you nothing. A bad idea caught after three weeks of development costs you everything.

What You Have Built

You have built a structured operating model for AI-assisted software development.

How software was being built before:

• Write a lengthy PRD: 60 minutes

• Hand off to engineering: Days

• Wait for QA: 90 minutes

• Review and revise: More days

• Total: Weeks

Now with Claude Code + gstack:

• Agent challenges and validates the idea

• Review the architecture in 5 minutes

• Agent builds, tests, and ships

• Total: Under an hour

Monthly impact (4 builds): 16 hours back and four features shipped that would have sat waiting for a developer.

What You Just Learned: Context Engineering

You did not just automate a task. You learned context engineering, the most important skill for operators in the AI era.

Old way of running a team:

• You wrote requirements

• You delegated to humans

• You followed up manually

• You waited for delivery

New way of running a team:

• You structure context (what the agent needs to know)

• You delegate to AI agents

• You review outputs

• You ship in the same session

The skill is the same: breaking down what needs to happen and communicating it clearly. The tool changed. The management thinking did not.

This is why operators are beating developers right now.

Developers are trained to obsess over syntax. They spend hours arguing about the perfect way to write a function or format a database query. But AI already knows the syntax. The bottleneck is no longer writing the code, the bottleneck is deciding what to build and how to sequence the work.

Operators know process. You know how to take an ambiguous business goal, break it down into requirements, assign roles, review the output, and push it live. You do this every day with human teams.

With gstack, you are simply applying that exact same operating playbook to a team of AI agents. In the age of AI, how you run the work is the competitive edge.

What to Build Next

Once you have run your first build cycle, one thing to add immediately:

Automate your after-action reviews. The /retro skill analyses your commit history and generates a weekly review: what shipped, what didn’t, and why. Run it every Friday.

Note: The gstack repository also includes /browse for browser-based QA and /canary for post-deploy monitoring. Both exist in the live repo, I haven't finished testing either yet, so I'll cover them properly once I have. That's my bar for writing about something.

The Bigger Picture

Garry Tan claims to have written 600,000 lines of code in 60 days (35% of which are tests). He is not a better developer than you. He is a better operator. He built a structured process, gave his AI agents clear roles, and managed the work like someone who knows how to get things shipped.

The developers who are struggling with AI tools are the ones who treat Claude Code like a smarter autocomplete. The operators who are winning are the ones who treat it like a team.

gstack is free. It is open source. And it is the closest thing to a YC-endorsed operating model for AI-assisted development that exists right now.

Your move.

Subscribe for more AI systems for operators →

References

[1] GitHub — garrytan/gstack:

[2] TechCrunch — “Why Garry Tan’s Claude Code setup has gotten so much love, and hate”:

[3] Garry Tan on X — gstack announcement:

[4] Medium — “gstack is not a dev tool. it’s Garry Tan’s brain on AI”:

Hey Friends 👋 Happy Friday

Here’s another weekly dose of AI ways of working.

J. Moss, a technical co-founder and GTM operator, wrote about a pre-seed founder who has two people on his team. The second one is Claude. He doesn’t call it a tool. He calls it his technical co-founder.

Moss walked through the founder’s actual day in detail.

The founder sent 40 emails last week. Every single one was different. He got 11 replies. That’s 27.5% , in an industry where the 2026 benchmark sits at 3.43%.

What this founder built is not a sales hack. It’s a demonstration of what AI operations actually looks like when someone treats Claude as a role, not a feature. And the skill that makes it work, breaking down a workflow, defining rules, reviewing outputs, is something every experienced manager already has.

Here’s exactly how he built it, and how you can set it up in 15 minutes.

Why This Only Works With Claude Code

Claude Code connects directly to your prospect lists, the live web, and your local files. It pulls the data itself. You don’t copy-paste anything.

That’s why this works. You don’t need to understand how the MCP connection works. You need to understand what it gives you — an analyst who does the research before you review it.

What You’ll Build

In 15 minutes, you will have an operating environment where Claude researches each prospect and rewrites your base email for them — one at a time, with your approval at every step.

•Time to build: 15 minutes

•Time saved: 4+ hours per week

•Outcome: Personalised emails for every prospect, saved and ready to send

Step 1: Connect Your Tools (5 minutes)

What you need:

•Claude Code installed

•A free Tavily API key (get one at tavily.com — free tier covers ~1,000 searches per month)

How to connect:

Open your Claude Code project folder.

2.Create or open your .mcp.json file.

3.Paste the following configuration block:

{

“mcpServers”: {

“tavily”: {

“command”: “npx”,

“args”: [”-y”, “tavily-mcp”],

“env”: {

“TAVILY_API_KEY”: “your-api-key-here”

}

}

}

}

1. Replace your-api-key-here with your actual Tavily key.

2.Restart Claude Code.

Operator Note: You are giving Claude Code live web access so it can research each prospect without you copying anything manually.

Step 2: Create Your Operating Environment (5 minutes)

Create a folder called /cold-outreach/. Inside, you need three files.

File 1: prospects.csv

A simple spreadsheet with these columns: Name, Company, Title, LinkedIn URL.

File 2: base-email.md

Your standard pitch. One draft. Keep it under 150 words. This is the template Claude will rewrite for each prospect.

File 3: CLAUDE.md — this is your operating environment. It loads every session and tells Claude exactly who you are, what you sell, and how to behave.

Copy this into your CLAUDE.md:

Adjust the workflow:

•Replace the [YOUR NAME], [COMPANY], and [WHAT YOU SELL] placeholders with your actual details.

•Add your tone examples at the bottom, this is what makes the output sound like you.

Step 3: Run It (5 minutes)

1.Open Claude Code in your /cold-outreach/ folder.

2.Type this single prompt:

Claude will read the first row of your CSV, search the web for that prospect, show you what it found, draft the email, and wait for your go-ahead before moving to the next one.

Review each version in /outputs/ before sending. You stay in control at every step.

What You’ve Built

Before:

After:

Time saved: 5.5 hours per week = 286 hours per year.

The real metric: 40 emails. 11 replies. 27.5% reply rate — against a 2026 industry benchmark of 3.43%.

What to Build Next

Once this is running, you can extend the same operating environment:

•Connect your CRM to automatically log sent emails and track replies without manual data entry.

•Add a signal monitor to trigger outreach automatically when a target company announces funding, a new hire, or a product launch.

•Build a follow-up sequence where Claude drafts a second-touch email based on whether the first one was opened.

Each of these is the same pattern: structure the context, delegate to Claude, review the output.

What You Just Learned: Context Engineering

You didn’t just automate a task. You learned context engineering.

Old Management:

•You wrote requirements.

•You delegated to a junior SDR.

•You followed up manually to check their research.

New Management:

•You structure context (what the agent needs to know, in CLAUDE.md).

•You delegate to Claude Code.

•You review outputs.

The skill is the same: breaking down what needs to happen and communicating it clearly. The tool changed. The management thinking didn’t.

This is why managers with a background in process design have an advantage most people haven’t noticed yet. You already know how to break down a workflow, define constraints, and review outputs. You’ve been doing context engineering for years. You just didn’t have an agent to run it.

One Ask

If you know someone using Claude Code in an interesting way, a workflow, a result, a setup that surprised you, reply and tell me. Every issue I feature one real example from someone in the operator community.

Subscribe for more AI Ops for Managers.

Sources:

•J. Moss. “He Calls Claude His Co-Founder. He Wasn’t Joking.” GTM AI Podcast / Substack. March 18, 2026. gtmaipodcast.com (Verified publicly accessible — no paywall. Contains the 40 emails / 11 replies claim verbatim.)

•Instantly.ai. “Cold Email Benchmark Report 2026.” January 12, 2026. instantly.ai

•Tavily MCP Server. GitHub. github.com/tavily-ai/tavily-mcp

Hey Friends 👋 Happy Tuesday

Here’s another weekly dose of AI ways of working.

You’ve seen the demos. AI agents that promise to automate your work, manage your life, and give you back your time. But when it comes to building your own, a critical question emerges: can you trust it? Can you build an AI assistant that has access to your files, your emails, and your private data without creating a massive security hole?

This was the central question I faced when I decided to build Benny, my own 24/7 AI assistant. I wasn’t interested in a toy. I needed a production-hardened agent that could handle real work, securely and reliably. The generic tutorials and superficial security advice I found online weren’t going to cut it. They talked about using a Mac Mini, which didn’t offer the 24/7 uptime I needed, and they glossed over the real security risks.

This post is the authentic story of how I built Benny. It’s a detailed account of the technical decisions, the security architecture, and the real-world trade-offs I made to create a powerful and trustworthy AI assistant. I’m sharing my entire process, from choosing the right infrastructure to implementing a multi-layered security stack, so you can build your own production-ready agent with confidence.

Why a VPS? The Foundation of a 24/7 Agent

My first major decision was choosing the right infrastructure. While many guides suggest using a local machine like a Mac Mini, I quickly realised that this approach wouldn’t meet my requirements for a production-ready agent. I needed a solution that offered 24/7 uptime, data isolation, and a predictable cost structure. After careful consideration, I chose to deploy Benny on a Hetzner CPX32 Virtual Private Server (VPS) with 8GB RAM, running Ubuntu 24.04.

Here’s a breakdown of my decision-making process:

For a total cost of around €11 per month, the Hetzner VPS provided the perfect balance of performance, reliability, and cost-effectiveness for a production-hardened AI assistant. It gave me a solid foundation to build upon, with the confidence that Benny would always be online and ready to work.

The Security Stack: A Multi-Layered Defence

With the infrastructure in place, my next focus was building a robust security stack. A single security measure is not enough. You need a multi-layered defence to protect your agent from various threats. Here’s the security architecture I implemented for Benny:

Complete security architecture for Benny on Hetzner CPX32: Cloud Firewall → UFW → Caddy TLS → Docker → OpenClaw loopback binding

This multi-layered approach ensures that Benny is protected at every level, from the application itself to the underlying infrastructure. The loopback-only binding is particularly important. It ensures that the OpenClaw agent is only accessible from the local machine, and not directly from the internet. This is a critical mitigation for vulnerabilities like CVE-2026-25253, which could allow an attacker to gain control of your agent if it’s directly exposed.

Reference architecture illustrating Docker container security principles for application isolation

The Caddy reverse proxy handles all external traffic, providing automatic TLS encryption and acting as a secure gateway. This means that all communication with Benny is encrypted, protecting sensitive data from eavesdropping.

Authentication: Leveraging Your Existing Claude Subscription

My next decision was how to authenticate with the language model. While the OpenClaw documentation often highlights using an API key, I made a deliberate choice to use the setup-token method with my Claude Max subscription. This approach has two significant advantages:

1.No API Billing: By using my existing Claude Max subscription, I avoid any additional API costs. All my agent’s interactions with the model are covered by my subscription.

2.Simplified Credential Management: The setup-token method generates a long-lived token that is easy to manage and rotate. It’s a more secure approach than hardcoding an API key in a configuration file.

Here’s how I set it up:

First, I generated a token on the VPS using the Claude Code CLI:

Then, I pasted the token into OpenClaw:

This command stores the authentication token in the ~/.openclaw/agents/<agentId>/agent/auth-profiles.json file, which OpenClaw uses to authenticate with the Anthropic API. This approach is not only more secure but also more cost-effective, as it allows me to leverage my existing investment in a Claude Max subscription. Note that the setup-token requires periodic renewal, so you’ll need to regenerate and update it when it expires to avoid authentication failures.

The Nitty-Gritty: Real-World Technical Decisions

Beyond the high-level architecture, building a production-ready agent involves a series of smaller, but equally important, technical decisions. Here are some of the key choices I made during the build process:

Telegram as the Interface: I chose Telegram as the primary interface for interacting with Benny. It’s fast, reliable, and has a robust bot API that makes it easy to integrate with OpenClaw. This allows me to send commands, receive updates, and interact with my agent from anywhere, on any device. The setup was straightforward: I created a new bot using BotFather, obtained the bot token, and configured OpenClaw to use it.

Brave Search Integration: For web search capabilities, I integrated Brave Search. It offers a privacy-focused alternative to Google and provides high-quality search results without the tracking. This aligns with my overall security-first approach and ensures that my agent’s search queries aren’t being logged or monetised by a third party.

No ClawHub Skills: I made a deliberate decision to use custom skills only, avoiding the community ClawHub repository. Independent security audits by Bitdefender and Cisco have documented a 17-26% vulnerability rate in community skills. For a production-hardened agent, this risk was unacceptable. Building custom skills takes more time upfront, but it ensures that every capability Benny has is vetted and secure.

CVE-2026-25253 Mitigation: During my research, I discovered a critical vulnerability (CVE-2026-25253) that affects OpenClaw instances that are directly exposed to the internet. By implementing loopback-only binding and using a reverse proxy, I ensured that Benny is protected from this vulnerability. This is a perfect example of why a security-first approach is essential when building AI agents.

These seemingly small decisions have a significant impact on the usability, security, and reliability of the agent. They are the details that separate a toy project from a production-ready tool.

What You’ve Built: A Foundation for Autonomous Work

By following this guide, you haven’t just built an AI assistant. You’ve built a production-hardened platform for autonomous work. You have a secure, reliable, and cost-effective system that can serve as the foundation for a wide range of automation tasks. You’ve learned how to think critically about AI security, how to design a multi-layered defence, and how to make real-world technical decisions that balance security, cost, and performance.

This is more than just a chatbot. It’s a digital employee that you can trust with real work. It’s a platform that you can extend and adapt to meet your specific needs. And it’s a testament to the power of a security-first approach to AI.

What’s Next: From Deployment to Reliable Behaviour

This article covers the infrastructure and security foundation. But deploying the agent is only half the battle — the real challenge is making it reliably useful. In upcoming posts, I’ll cover the workspace and memory architecture that prevents your agent from becoming a “goldfish brain” after two weeks, and the iterative behaviour design process that turns a deployed agent into a trustworthy digital team member. Building the infrastructure is the easy part. Teaching it to think like you is where the real work begins.

Conclusion: The Concrete Outcome

I built a production-hardened AI assistant for €11 per month on a Hetzner CPX32 VPS with an 8-layer security stack: Cloud Firewall, UFW, fail2ban, SSH hardening, Caddy TLS, Docker isolation, loopback binding, and non-root execution. Authentication runs through my existing Claude Max subscription via setup-token, avoiding API billing entirely. The agent operates 24/7 with 99.9% uptime, accessible via Telegram from anywhere.

Total monthly cost: €11 for the VPS, plus the Claude Max subscription you likely already have. No additional API charges. No expensive hardware. No compromises on security. That’s the concrete takeaway: you can build a trustworthy AI assistant without breaking the bank or sacrificing your data privacy.

Until the next one!

Andres

Hey Friends 👋 Happy Thursday

Here’s another weekly dose of AI ways of working.

You’ve felt the frustration. You’re 20 messages deep into a complex task with an AI agent. You’ve fed it documents, clarified requirements, and iterated on the code. Then, it happens. The agent gets confused, the context window degrades, or you accidentally hit /clear.

Suddenly, the AI has total amnesia. All that progress is gone. It feels less like delegating and more like babysitting a brilliant but impossibly forgetful intern.

This isn’t a user error; it’s a system limitation. And overcoming it requires a new skill: context engineering. This is the emerging discipline of designing the information environment where an AI agent operates. It’s the secret to making them reliable, and it reflects the principles that are making AI agent companies like Manus AI worth billions.

The core idea is simple but profound: stop treating the chat window like a permanent brain and start using the filesystem as a persistent one.

The core concept: A volatile Context Window (RAM) vs a persistent Filesystem (Disk)

Your AI’s Chat Window is RAM, Not a Hard Drive

The fundamental principle of context engineering is this:

Context Window = RAM (volatile), Filesystem = Disk (persistent). Anything important gets written to disk.

An AI agent’s chat conversation is like your computer’s RAM, incredibly fast but temporary. When the conversation gets too long or you clear the chat, that memory is wiped. Your project’s files, however, are like your hard drive. They persist.

Instead of trying to stuff everything into the agent’s short-term memory, you create a simple, external memory system using plain text files.

The Community’s Hack: A 3-File System for Perfect Recall

This pattern, gaining widespread adoption in the open-source AI community, relies on just three simple Markdown files that live in your project directory. For Claude Code users, the setup is immediate and practical:

This system acts as the AI’s external brain, giving it a perfect, persistent memory of your project.

Why It Matters: The Recovery Scenario

The difference this makes is night and day. The recovery scenario shows the power of this approach better than any abstract explanation.

Without Planning Files:

You work with an agent for 25 messages. The context degrades, and the agent gets confused. You type /clear. The agent has zero memory of what you’ve built. You spend the next 20 minutes re-explaining everything, inevitably missing details.

With Planning Files:

You work with an agent for 25 messages, and it updates the files as it goes. The context degrades, and the agent gets confused. You type /clear. You give one simple instruction:

The agent reads the files and knows exactly what’s been done, what’s next, and the rules to follow. Zero progress is lost.

The dramatic difference between chaotic re-explanation and smooth recovery

This is the workflow: Read from disk at the start of a session. Write to disk at the end. Everything important lives on the filesystem, not in the conversation.

Why This Principle is Worth Billions

While Manus AI’s exact internal architecture isn’t public, its success points to a crucial truth: the ability to create reliable, autonomous agents that can execute complex, multi-step tasks is immensely valuable. Manus AI went from a $500 million valuation to a $2 billion acquisition by Meta in just eight months because it solved this problem at scale, achieving over $100 million in annual recurring revenue.

The value isn’t in a single tool, but in the underlying principle of persistence and reliability. The persistent planning pattern, now popular in the open-source community, is a direct and practical application of this billion-dollar principle.

This isn’t just a clever trick for developers. It’s a foundational pattern that makes autonomous AI agents actually work in production environments. And now, with tools like Claude Code becoming more accessible, this same pattern is available to operators, managers, and founders who want to build real applications without becoming software engineers.

From Prompter to Engineer

If you’re a project manager, operations lead, or founder, this pattern unlocks a new capability: the ability to delegate complex, multi-step work to AI agents with confidence. You already know how to break down projects, define requirements, and manage workflows. Those are the exact skills needed for context engineering.

The difference is that instead of managing human team members, you’re managing an AI agent’s information environment. You’re structuring the context it needs to succeed, defining the rules it should follow, and tracking the progress it makes—all using simple text files.

This is the future of operations work. The managers who learn to structure context effectively will be the ones who can build and automate at a scale that was previously impossible without large engineering teams.

Your Turn: Build Your First Persistent Agent

Ready to try it? The best way to understand the power of this pattern is to use it.

1.Create a new project folder.

2.Inside it, create three files: claude.md, task_plan.md, and progress.md.

3.Start your next Claude Code session by telling it to read those files.

A real example: CLAUDE.md defining project rules, task_plan.md tracking tasks, and progress.md logging what’s been done

Follow for more AI for operators.

Andres

References

[1] Meta Buys AI Startup Manus for More Than $2 Billion - WSJ

[2] Effective context engineering for AI agents - Anthropic

[3] Meta Acquires Manus AI for $2B - ALM Corp

[4] GitHub - OthmanAdi/planning-with-files

[5] What is Manus, the Chinese-founded AI startup Meta is buying for over $2 billion? - Business Insider

Hey Friends 👋 Happy Tuesday

Here’s another weekly dose of AI ways of working.

Anthropic just quietly released Agent Teams in Claude Code, and whilst it sounds like a developer-only feature, it’s actually a preview of how management is about to change. This isn’t just about writing code faster; it’s about structuring and delegating complex work to a team of AI agents, a skill set that every manager and operator already possesses.

We’ve been building in teams for decades. Now, AI is learning to do the same. Single AI agents often hit a performance wall on complex tasks, their context degrading as the scope expands. The solution isn’t a bigger context window; it’s a better team structure. Just as you wouldn’t CC the entire company on every email, AI agents shouldn’t be burdened with irrelevant information when tackling a specific problem.

How Agent Teams Work: The New AI Operating Model

Agent Teams introduce a new paradigm for AI-powered work. One Claude Code session becomes the “team lead,” which then spawns independent “teammates.” Each teammate operates within its own context window, allowing for specialised roles and focused effort. They coordinate through a shared task list and can message each other directly, mirroring the collaborative dynamics of a human team.

This structure allows for true parallel processing. One agent can be researching a problem, another can be drafting a document, and a third can be reviewing the output, all simultaneously. This is a significant leap from the sequential, single-threaded nature of most current AI assistants.

The Killer Feature: Delegate Mode

The most significant aspect of Agent Teams for managers is a setting called “delegate mode.” When enabled, the lead agent is prohibited from performing any implementation work itself. Its sole function is to coordinate: assign tasks, manage scope, and synthesise results. It becomes a pure project manager.

To activate delegate mode, you start a team first, then press Shift+Tab to cycle into this coordination-only mode.

This is a profound shift. The skills that make this mode effective are not coding skills; they are management skills. The ability to write clear briefs, define distinct roles, and maintain a focused scope becomes the primary driver of success. Your expertise in breaking down complex projects and managing teams is now directly transferable to orchestrating AI agents.

Proof in Practice: Building a C Compiler

To stress-test this new capability, Anthropic tasked a team of 16 Claude agents with building a 100,000-line C compiler from scratch. The agents worked in parallel on a shared codebase, managed through Git, with minimal human intervention. The human role was not to build, but to set standards, design high-quality tests, and make crucial judgement calls. The result was a functional compiler capable of building the Linux kernel.

This experiment demonstrates that the future of managing AI-driven work is not about becoming a programmer, but about becoming a better governor. The value shifts from execution to oversight, from doing the work to defining what work is done and how to validate it.

How to Start Experimenting

Agent Teams requires a one-time setup to enable the experimental feature. You need to add a single configuration line to your Claude Code settings, and after that, you orchestrate teams using plain English prompts.

Step 1: Enable Agent Teams (one-time setup)

Add this to your settings.json file in Claude Code:

{

“env”: {

“CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS”: “1”

}

}

Step 2: Start a team with a natural language prompt

Once enabled, you simply tell Claude what you want to achieve and the roles you want your AI team to play. For example:

Claude will then create the team, spawn the specialist agents, and begin coordinating the work based on your prompt. After the initial setup, it’s just a delegation instruction.

Potential Use Cases for Knowledge Work

Agent Teams are most effective when tasks can be parallelised and when different perspectives add value. Whilst the feature was designed primarily for software development, the architecture suggests promising applications for knowledge work. Here are scenarios where managers and operators could potentially leverage this capability:

Root Cause Analysis with Competing Hypotheses

Imagine your sales have suddenly dropped 20% this month. The cause is unclear. Instead of sequentially testing theories, you could spawn three agents. Agent 1 investigates a potential issue in your marketing funnel. Agent 2 analyses recent competitor moves. Agent 3 reviews customer support tickets for new complaints. They work in parallel to disprove each other’s theories, and the one that survives is likely your answer. This mirrors how a management team would tackle a crisis, but at machine speed.

Parallel Document Review

You’ve just drafted a critical 50-page quarterly report. Instead of a slow, sequential review process, you could assign different agents to review the same document through different lenses. Agent 1 checks for financial accuracy against the raw data. Agent 2 reviews for clarity, tone, and consistency with brand voice. Agent 3 acts as a legal reviewer, flagging any potentially problematic language. The lead agent then synthesises all feedback into a single, comprehensive revision list.

Multi-Angle Market Research

When exploring a new business opportunity, you could have agents investigate from different perspectives simultaneously. Agent 1 researches the total addressable market and growth projections. Agent 2 builds a detailed profile of the top three competitors. Agent 3 gathers data on regulatory hurdles and compliance requirements. Each agent operates independently, and the lead synthesises the findings into a cohesive market analysis report.

Note: These knowledge work applications are suggested use cases based on the Agent Teams architecture. Whilst Claude Code has been successfully used for non-coding tasks like complex task management and research , the specific Agent Teams feature is currently optimised for software development workflows. As the technology matures, we expect to see more documented applications in knowledge work domains.

The Future is Governance

As AI agents become more capable, the primary role of human managers will shift from task execution to governance. We will be the ones who set the direction, define the constraints, and ultimately, make the strategic decisions that AI cannot. The release of Agent Teams is one of the first concrete steps in this direction.

The skills that made you effective at managing human teams, clear communication, task decomposition, scope management, quality standards, are the exact skills that make Agent Teams effective. This isn’t a replacement of management; it’s an evolution of the medium through which management operates.

Agents will do the work. Humans will do the thinking.

Want to go deeper on AI for operators? Follow for more breakdowns on how to leverage AI in your management workflow.

Until the next one!

Andres

Hey Friends 👋 Happy Thursday

Sharing these insights based on Anthropics Use Cases

Managers, how much of your week is spent on work that doesn’t require your strategic mind? Chasing status updates, gathering data from a dozen different tools, and formatting reports. It’s the operational drag that keeps you from the high-impact work you were hired to do. What if that busywork could disappear?

Anthropic just released a set of use cases for their AI assistant, Claude, and they offer a clear glimpse into the future of management. It’s not about being replaced by AI; it’s about being elevated. The new manager playbook is about shifting from a “doer” to a “reviewer and delegator” of tasks to AI agents.

Why Claude, Not ChatGPT?

Before we dive in, let’s clarify why this is different. You’ve likely used ChatGPT. You feed it information, it gives you a response, and you copy-paste that into your workflow. The game-changer with tools like Claude, and its more powerful version, Cowork, is tool access. They connect directly to your existing software stack, your project management tools, your cloud storage, your communication platforms. They pull the data themselves, so you don’t have to.

ChatGPT: You feed it → It writes → You copy-paste

Claude/Cowork: It accesses tools → Pulls data → Generates + saves

This seemingly small difference is what unlocks true operational leverage.

The Three Types of Managerial Work AI Can Automate Today

An analysis of Claude’s 15 new use cases reveals three clear categories of managerial work that are ripe for automation:

1. Cross-Platform Data Aggregation & Synthesis

This is the most common and immediately valuable category. It’s for any task where you find yourself opening multiple tabs or applications just to get a complete picture.

Examples:

•Building a daily briefing: Instead of you checking Slack, Notion, and your team dashboard, an AI agent does it overnight and presents you with a summary of priorities.

•Surfacing themes from feedback: The agent can read call transcripts, CRM notes, and support tickets to identify recurring customer issues.

•Pulling metrics from dashboards: No more manual data entry from your analytics tools into a spreadsheet.

Manager Takeaway: If your morning starts with “checking in on things,” this is your starting point. You can save 30-60 minutes every single day.

2. Batch Processing of Repetitive Operations

This category is about tackling tasks that you do over and over again, often for a list of items. Think of it as applying the same set of steps to a folder full of files.

Examples:

•Processing a batch of vendors: The agent can read vendor files, add them to your tracking system, generate contracts, and even fill out intake forms.

•Reconciling transactions: It can match transactions across different bank exports and flag discrepancies for your review.

•Organising scattered documents: Point it at a messy folder, and it will sort and rename files based on their content.

Manager Takeaway: If you have a recurring task that involves a list of items, you can likely automate it. This is about eliminating the monotonous, one-by-one work.

3. Professional Deliverable Creation

This is where AI starts to feel like a true junior team member. It’s not just about processing information; it’s about creating polished, professional outputs.

Example:

•Sizing a market: You can ask a question, and the agent will research it, perform calculations, and deliver a PowerPoint presentation, an Excel workbook with the methodology, and a Markdown document with citations.

Manager Takeaway: Your role shifts from creating the first draft of a presentation to refining the narrative of an AI-generated one. This is a massive time-saver for strategy, business development, and operations roles.

The New Core Skill: Implementing AI Management Systems

In the old world, you implemented processes. In the new world, you implement AI management systems. This is the fundamental shift. You didn’t just automate a task; you learned the basics of context engineering—the skill of designing and directing these systems.

Old Management:

•You wrote requirements

•You delegated to humans

•You followed up manually

New Management:

•You structure context (what the agent needs to know)

•You delegate to AI agents

•You review outputs

The core management thinking—breaking down what needs to happen and communicating it clearly—remains the same. But the execution has fundamentally changed. You are no longer just managing people; you are managing systems.

Old Way vs. New Way: How AI-Powered Managers Operate

Here’s how managers who are embracing AI are structuring their work:

The Old Way: The Manual Grind

•Manually check Slack for urgent messages (10 mins)

•Scan Asana for overdue tasks and project updates (10 mins)

•Review the calendar for the day’s meetings (5 mins)

•Read through key email threads for context (15 mins)

•Compile everything into a personal to-do list or briefing doc (5 mins)

•Total: 45 minutes

The New Way: The AI-Powered Operator

•An AI agent compiles the briefing overnight.

•The manager reviews the summary in 5 minutes.

•They spend their time adjusting priorities and making decisions, not gathering data.

•Total: 5 minutes

Time saved: 40 minutes per day = 260 hours per year. That’s over six weeks of work back in your calendar.

What This Means for Your Role as a Manager

This isn’t a threat to your job; it’s an opportunity to elevate it. The analysis of these use cases makes it clear:

•You’re not being replaced; you’re being promoted. You move from being a doer of administrative tasks to a reviewer and decision-maker.

•The critical skill isn’t technical. It’s about knowing where your context lives and how to structure a request, the same skills you use to delegate to your team.

•The biggest ROI is in repetition, not complexity. Don’t start with your most complex problem. Start with the simple task you do ten times a week.

Join the Vanguard of AI-Powered Operators

The transition from manager to AI-powered operator won’t happen overnight. It requires a new way of thinking and a community to learn with. This is more than just adopting a new tool; it’s about fundamentally redesigning how you work.

By following this Substack, you’re not just getting another newsletter. You’re joining a growing community of forward thinking managers and operators who are building the future of work. Here, we’ll go beyond the hype and provide you with the practical, step-by-step guides you need to implement these systems yourself.

Subscribe now to get actionable insights, learn from real-world case studies, and master the skill of implementing AI management systems. Let’s build the future, together.

This post was inspired by the recently released use cases from Anthropic. You can explore them all here.

Andres

Hey Friends 👋 Happy Tuesday

Here’s another weekly dose of AI ways of working.

You spend hours wrestling with an AI, trying to get the right output. You tweak a word here, add ‘please’ there, and hit ‘generate’ like you’re pulling a slot machine lever. Sometimes you win, but mostly you get generic, unusable nonsense. It feels like a guessing game you can’t win.

What if there was a rulebook for the slot machine? A systematic, evidence-based guide that turns prompting from a dark art into a reliable science. There is. A comprehensive academic paper just synthesised 1,565 different research papers into a 79-page definitive guide on prompt engineering. It’s dense, but it provides a clear framework for getting consistent, high-quality results from any LLM.

Today, I’m breaking down the most actionable insights for operators, COOs, and PMs. You’ll learn the core techniques that separate amateur prompting from professional-grade AI interaction. And yes, you can download the full academic paper for free at the end.

A structured framework for systematic AI interaction—moving from chaos to predictable outcomes.

Why This Guide (Not Just Another Blog Post)

Most advice on prompting is based on one person’s trial and error. It’s anecdotal and often outdated within weeks. This is different.

This guide is the output of a systematic review of virtually all academic literature on prompting. It’s not one person’s opinion; it’s a synthesis of the entire field of research.

That’s why this is a game-changer. It gives you a reliable system, not just a list of tricks.

What You’ll Learn

We’ll translate the academic jargon into four powerful, actionable techniques you can use immediately to improve your AI outputs. You’ll learn how to stop guessing and start engineering your prompts for predictable success.

Time to read this post: 7 minutes

Time saved per week: 2-3 hours of re-writing and correcting AI outputs

The Core Four: Actionable Prompting Frameworks

Here are the four most critical techniques from the research that you can apply right away.

1. Teach with Examples: In-Context Learning (ICL)

Instead of just telling the AI what to do, show it. ICL means providing a few examples of the task directly in your prompt. The research highlights six factors that determine success.

The research identifies six critical design decisions that transform few-shot prompting from random to reliable. Quantity matters—performance improves with more examples, particularly up to 20 for standard models and beyond for long-context models. Ordering is surprisingly critical; the sequence of your examples can shift accuracy from 50% to over 90%. Format consistency is essential—using the same structure (such as “Q: / A:”) across all examples improves performance. Similarity helps; examples that closely resemble your actual query tend to work best. Label quality is less critical than you might think—for large models, the structure of examples matters more than their correctness. Finally, label distribution should be balanced to avoid bias toward any single category.

Operator’s Action: When asking an AI to categorise customer feedback, don’t just ask. Show it first. Provide 2-3 examples for each category (Bug Report, Feature Request, Billing Issue) before the real data.

A prompt showing clear examples of a classification task before the final instruction—this is In-Context Learning in action.

2. Force the Reasoning: Chain-of-Thought (CoT)

For complex tasks, AI often rushes to an answer and makes mistakes. CoT forces it to slow down and ‘show its work’. The simplest way to do this is with a single phrase.

Operator’s Action: When you have a complex reasoning task (such as “Based on these three reports, what are the top 5 risks for Q3?”), simply add this phrase to the end of your prompt:

This simple addition, known as Zero-Shot CoT, is proven to dramatically improve the AI’s reasoning ability, leading to more accurate and logical conclusions. The research shows that this technique significantly enhances performance on mathematics and reasoning benchmarks without requiring any examples.

3. Break It Down: Decomposition

Complex projects aren’t tackled in one go, and neither should complex prompts. The research validates the ‘decomposition’ method, where you instruct the AI to break a large task into smaller, sequential sub-problems.

Operator’s Action: Instead of asking the AI to “Write a project plan for our new product launch,” guide it with decomposition.

This turns a single, overwhelming request into a structured process that the AI can execute far more reliably. The guide identifies several decomposition techniques, including Least-to-Most (starting with the simplest sub-problem and building up), Plan-and-Solve (planning the steps first, then executing each), and Tree-of-Thought (exploring multiple reasoning paths simultaneously).

A visual representation of task decomposition, breaking a complex query into planned, iterative sub-tasks with feedback loops.

4. Make It Check Itself: Self-Criticism

Even with good prompts, AIs can make errors. The most advanced technique is to build a verification step into your prompt itself. This is the principle of ‘self-criticism’.

Operator’s Action: For high-stakes outputs like a client proposal or a financial summary, ask the AI to verify its own work.

This forces a loop of generation and verification, catching errors before they get to you. The research identifies several self-criticism methods, including Chain-of-Verification (where the AI generates an answer, creates verification questions, answers them, and produces a final output), Self-Refine (an iterative feedback loop where the AI critiques and improves its work), and Self-Consistency (generating multiple answers and selecting the most common one).

What You’ve Built

By moving away from guessing and adopting these four frameworks, you’ve built a systematic process for interacting with AI. You’ve stopped being a user and started being an operator.

Before:

•Trial-and-error prompting: 15-20 minutes per task

•Inconsistent, often unusable results

•Manual re-work and correction: 30+ minutes

•Total: 45-60 minutes per complex task

After:

•Structured, framework-based prompting: 5 minutes

•Consistent, reliable, and predictable results

•Minor review and edits: 5-10 minutes

•Total: 10-15 minutes per complex task

Time Saved: Over 30 minutes per task, which adds up to hours every week.

Get the Full Guide

These four techniques are just the beginning. The full 79-page academic paper provides a deep dive into 58 distinct prompting methods, including security considerations (prompt hacking and hardening measures), benchmarking frameworks, multimodal prompting (images, audio, video), and advanced agent-based techniques.

The guide covers critical topics for operators, including how to evaluate prompting techniques systematically, how to protect against prompt injection attacks, and how to handle alignment issues like bias and overconfidence. It’s a comprehensive resource grounded in rigorous academic research, not marketing hype.

Download the full, free Prompt Engineering guide here →

What to Build Next

Once you’ve mastered these four core techniques, you can explore more advanced frameworks from the guide. Consider implementing Role Prompting to assign specific expertise to the AI (such as “You are an experienced COO”), which can improve domain-specific outputs. Experiment with Emotion Prompting by incorporating phrases of psychological relevance (such as “This is important to my career”) to potentially enhance performance on benchmarks and open-ended tasks. Explore Ensembling techniques like Self-Consistency, where you generate multiple answers and select the most common one for higher confidence. Finally, investigate Retrieval Augmented Generation (RAG) to connect your AI to external knowledge bases and real-time data sources.

What’s the most frustrating thing you’re trying to get an AI to do?

Andres

References & Additional Context

This post is based on a comprehensive systematic review of prompting techniques, conducted using the PRISMA methodology. The review analysed 1,565 academic papers from arXiv, Semantic Scholar, and ACL to identify 58 distinct text-based prompting techniques. The full paper includes detailed taxonomies, benchmarking results (including tests against the MMLU dataset), and a real-world case study on identifying signals of suicidal crisis in support text.

The guide is maintained as an evolving resource at LearnPrompting.org, with an up-to-date list of terms and techniques. It represents the first comprehensive attempt to standardise terminology and create a robust directory of prompting methods for both developers and researchers.

Key Research Highlights:

•Systematic Review: Machine-assisted review using GPT-4 with 89% precision and 75% recall

•Scope: Focuses on prefix prompts (not cloze prompts) and hard prompts (not soft/continuous prompts)

•Coverage: Text-based, multilingual, multimodal, and agent-based prompting techniques

•Practical Focus: Task-agnostic techniques that can be quickly understood and implemented

For operators, managers or COOs, the most relevant sections are Section 2.2 (Text-Based Techniques), Section 4.2 (Evaluation), Section 5.1 (Security), and Section 6 (Benchmarking). These sections provide immediately actionable frameworks for improving AI reliability in operational contexts.

Hey Friends 👋 Happy Friday

Here’s a tutorial to get you started on Claude Code journey.

How much of your day is lost to digital paper-shuffling? Switching between Asana, Slack, and Google Drive, manually compiling reports, and copy-pasting updates. This isn’t high-value work; it’s context-switching that kills your focus and drains your energy.

What if you had a single command centre? An AI assistant that lives in your operating environment, connected to all your tools, ready to pull information and execute tasks for you.

Here’s how to build it in under 10 minutes by installing Claude Code on your Mac.

The Claude Code terminal showing a successful login with ASCII art logo

Why Claude Code (Not ChatGPT)

ChatGPT is a powerful brainstorming partner, but it’s a closed box. It can’t access your project boards, read your documents, or check your team’s Slack channels. You are its hands and eyes, feeding it information manually.

Claude Code is different. It connects directly to your operating environment—the ecosystem of tools where your work actually happens.

Claude Code doesn’t need you to copy-paste. It securely connects to your tools to pull data and automate tasks, turning your computer into a true AI-powered command centre.

What You’ll Build

You are installing the foundational layer for your AI command centre. This guide gets the tool onto your Mac and ready to be connected to your operating environment. It’s the first step toward automating reports, summarising projects, and delegating your most repetitive tasks to an AI assistant.

•Time to install: 10 minutes

•Potential time saved: 5+ hours a week, once you build your workflows.

Step 1: Install Your Command Centre (5 minutes)

This step installs Claude Code using your Mac’s Terminal—a simple, text-based way to give your computer instructions. We recommend using Homebrew, a trusted package manager for Mac.

What you need:

•A Mac with macOS 10.15 or newer

•A Claude.ai account

To install via Homebrew:

1.Open the Terminal app (you can find it using Spotlight search).

2.Copy and paste the following command, then press Enter:

brew install --cask claude-code


Step 2: Connect to Your AI Assistant (3 minutes)

Now, you’ll log in to give your new command centre its brain.

1.In the same Terminal window, type claude and press Enter:

claude

2.A prompt will appear to log you into your Claude.ai account. Follow the on-screen instructions.

After successful login, you'll see the Claude Code welcome screen with permission rules. This is where you configure which tools Claude Code can use.

Step 3: Test Your Connection (2 minutes)

Let’s confirm your command centre is online and ready for instructions.

1.Run the built-in help command:

/help

2.You should see a welcome message and a list of available commands. This confirms your AI assistant is ready to go.

What You’ve Accomplished

You’ve installed the Claude Code command centre on your Mac. You haven’t connected it to your tools yet, but you’ve laid the essential foundation. You’ve moved beyond simply chatting with a web-based AI and now have a powerful tool ready to be integrated into your operating environment.

Before:

•Manually checking Asana, Slack, and Drive for updates.

•Spending hours compiling weekly reports.

•Your time: Consumed by low-value, repetitive tasks.

After (Your New Potential):

•The ability to build workflows that summarise project status with a single command.

•The foundation to create automated report drafts.

•Your time: Can be freed up for high-impact strategic work once you build these connections.

What to Build Next

Your new command centre is ready. Now you can teach it workflows like:

•"Summarise all completed tasks in the ‘Q4 Launch’ project this week.”

•"Draft a project update based on the latest in the #project-alpha channel.”

•"Find the latest version of the ‘Go-to-Market’ strategy doc and summarise it for me.”

Get Started

Welcome to the new paradigm. AI Ops isn’t about replacing what you do, it’s about amplifying what you already know. Your context management skills, your process knowledge, your understanding of how work actually flows, these are the foundations that matter now.

Join a growing community of Project Managers, Operators, and Founders who are building the future of work. I’ll be sharing selective insights and tutorials on how to use Claude Code and other tools for project managers and managers who aspire to be AI Operators. This is where you’ll find tutorials on AI Ops, delivered to operators who understand that context management beats code.

Andres

Hey Friends 👋 Happy Wednesday

Here’s another weekly dose of AI ways of working.

You spend your day juggling different hats. One moment you’re a project manager, the next a data analyst, and the next a content strategist. Each role has its own set of tools, its own context, and its own cognitive load. The constant switching is exhausting. The manual, repetitive work of moving information between applications feels like a tax on your productivity. What if you could build an automated operating environment that manages this context for you, freeing you up to focus on the high-judgement work that truly matters?

This is the promise of Claude Cowork, a new tool from Anthropic that’s empowering non-technical operators to build agentic workflows that automate the tedious, manual tasks that consume their days. This isn’t just another chatbot. It’s a fundamental shift in how we interact with our digital workspaces.

Why Claude Cowork (Not ChatGPT)

ChatGPT and other browser-based chat models are powerful tools for generating text, but they’re fundamentally limited by their inability to interact with your local files and applications. You’re still the one responsible for copy-pasting information, managing context, and executing tasks.

Claude Cowork, on the other hand, is designed to be an active participant in your workflow. It operates directly on your computer, within the folders you specify, and can interact with your applications through a growing ecosystem of connectors. This distinction is crucial.

This is the difference between an assistant that can write a report for you and an assistant that can research the report, write it, and save it to the correct project folder. It’s the shift from manual tool-juggling to an automated, agentic workflow.

Beyond the Case Study: How Other Businesses Are Using Cowork

While Dr Pean’s story is a powerful example of individual productivity, the applications of Claude Cowork extend far beyond a single user. Across various industries, businesses are discovering new ways to leverage this technology to streamline operations, enhance creativity, and unlock new efficiencies.

For instance, marketing teams are using Cowork to automate the entire content lifecycle, from initial research and content creation to distribution and performance analysis. A single prompt can trigger a workflow that generates a blog post, creates social media snippets, designs accompanying graphics, and schedules the content for publication across multiple platforms. This frees up marketers to focus on strategy and creative ideation, rather than getting bogged down in the mechanics of content production.

In the legal field, paralegals and legal assistants are using Cowork to accelerate document review and analysis. By pointing Cowork to a folder of case files, they can quickly extract key information, identify relevant precedents, and generate summaries of complex legal documents. This not only saves countless hours of manual work but also reduces the risk of human error.

Even in traditionally non-technical fields like real estate, agents are using Cowork to automate the creation of property listings, market analysis reports, and client communications. By simply providing a few key details about a property, Cowork can generate a compelling listing description, pull relevant market data, and draft personalised emails to potential buyers.

These are just a few examples of how businesses are using Claude Cowork to transform their operations. The common thread is a shift away from manual, repetitive tasks and towards a more automated, agentic way of working. As the technology continues to evolve, we can expect to see even more innovative use cases emerge, further blurring the lines between technical and non-technical roles.

Case Study: The Surgeon, the CEO, and the Automated Operating Environment

To understand the transformative potential of Claude Cowork, let’s look at the real-world use case of Dr Christian Pean, an orthopaedic trauma surgeon, academic, and CEO of a health tech startup. Dr Pean was struggling with the cognitive overhead of switching between his multiple professional “pillars,” as he calls them. His challenge wasn’t a lack of time, but the mental tax of constantly shifting contexts.

Dr Pean found his answer in Claude Cowork. By structuring his digital workspace around Cowork’s folder-based operation, he was able to create an automated operating environment that manages the context of his different roles. This is the key insight: Cowork isn’t just a chatbot, but a system that operates within your existing file structure.

The 6:15 AM Dispatch: Five Parallel Workflows Before Breakfast

Dr Pean’s morning ritual is a powerful demonstration of this new paradigm. At 6:15 AM, he dispatches five complex tasks to Claude Cowork in parallel, and then steps away to focus on his morning routine. When he returns, the deliverables are waiting for him.

Here are the five tasks he automates. Email Triage and Response Drafting: Cowork scans his inbox, prioritises important tasks, and drafts responses to straightforward emails. Presentation Preparation: It reviews existing PowerPoint files in a project folder and creates a structured outline for a new presentation. Content Calendar Planning: It searches the web for relevant stories and organises them into a branded HTML content calendar for his Substack newsletter. Downloads Folder Organisation: It categorises and files months of accumulated downloads into their relevant project folders. Deep Research Report: It analyses a complex industry report and creates an interactive HTML brief, complete with citations, tailored to his company’s specific needs.

This isn’t science fiction. This is what’s possible today for non-technical operators who are willing to rethink their workflows. Dr Pean isn’t writing code. He’s using natural language to direct an AI agent to perform complex, multi-step tasks.

What You’ve Built: A New Way of Working

By embracing this new paradigm, you’re not just automating tasks. You’re building a new way of working. You’re shifting from a reactive, tool-juggling approach to a proactive, agentic one. You’re creating an automated operating environment that manages context, offloads manual work, and frees you up to focus on what you do best: making high-judgement decisions.

The transformation is stark. Before, you were manually switching between a dozen different applications, losing time and focus to context switching, and wasting hours on repetitive, low-value tasks. After, you have a single interface to manage all your workstreams, an AI agent that manages context for you, and hours of your time reclaimed each week.

What to Build Next

Once you’ve started to build your own automated operating environment, the possibilities are endless. You could create a workflow that monitors your competitors’ websites, social media, and news mentions, and delivers a weekly intelligence briefing to your inbox. You could build a system that automatically organises your contacts, tracks your interactions, and reminds you to follow up with important connections. You could design a workflow that transcribes your meetings, summarises the key decisions and action items, and distributes the notes to all attendees.

Get Started

Welcome to the new paradigm. AI Ops isn’t about replacing what you do, it’s about amplifying what you already know. Your context management skills, your process knowledge, your understanding of how work actually flows, these are the foundations that matter now.

Join a growing community of Project Managers, Operators, and Founders who are building the future of work. Selective insights and tutorials on AI Ops, delivered to operators who understand that context beats code.

Hey Friends 👋 Happy Tuesday

Here's your weekly dose of AI ways of working.

Anthropic just solved the context-switching problem. For months, operators told me that Model Context Protocol (MCP) was too technical. Anthropic listened. Now, you can see and interact with your favourite tools directly within Claude. This isn’t about automating workflows; it’s about bringing all your business tools into one workspace where context never gets lost.

Why This Changes Everything for Operators

If you’ve ever felt the frustration of copying and pasting information between different applications, you’ll understand the power of this update. The constant context-switching between tools doesn’t just waste time; it fragments your thinking and breaks your workflow. Every time you jump from your project management tool to Slack, then to your analytics dashboard, you’re losing the thread of what you’re trying to accomplish.

Other AI tools connect to your software and execute commands blindly. They don’t understand the relationships between your tasks, your team’s conversations, and your business metrics. Claude now works like a colleague who understands your entire workflow. Context flows seamlessly between your tools, creating a single, unified workspace where everything connects.

This is a massive productivity booster. The barrier to entry isn’t technical skill anymore, but whether you understand the context of your own workflows. If you know how your work actually flows, what information feeds into what decisions, which tasks depend on which conversations, you’re already ahead.

What’s New: Interactive Tools That Actually Make Sense

Claude’s latest update introduces interactive tools through MCP Apps. This means you can now work with apps like Asana, Figma, and Slack without ever leaving the Claude interface. Instead of just getting text-based responses that you then have to manually input into your tools, you now get rich, interactive interfaces from your tools themselves.

Imagine building a flowchart in Figma based on a conversation with Claude, and then being able to edit that flowchart right there in your conversation. Or pulling real-time analytics from Amplitude and adjusting the parameters to explore different trends, all without opening a new tab. The work happens where the context lives.

From my own testing, Claude’s ability to retain context from conversations is a significant advantage over competitors like ChatGPT. This new update supercharges that capability. When Claude can see what you’re doing in Asana, pull data from Amplitude, and draft messages in Slack; all whilst maintaining the full context of your conversation—it becomes something fundamentally different from a chatbot. It becomes your operating environment.

Real Use Cases That Save Hours Every Week

The difference between a feature announcement and a productivity breakthrough is whether you can actually use it. Here’s how these interactive tools translate into real time savings for operators.

Project Management That Flows From Conversation. You’re discussing a new initiative with Claude, brainstorming the key milestones and dependencies. Instead of taking notes and then manually creating a project in Asana, you ask Claude to create that project structure. It appears as an interactive Asana interface right in your conversation. You can see the tasks, adjust deadlines, and assign team members without leaving Claude. What used to take 30 minutes of administrative work now happens in real-time as part of your strategic thinking.

Data Analysis Without the Context Switch. You need to understand user behaviour trends for the past quarter. You ask Claude to pull data from Amplitude, and instead of getting a text summary, you get an interactive dashboard. You can drill down into specific cohorts, adjust date ranges, and filter by different parameters, all whilst discussing the implications with Claude. The analysis and the insight generation happen in the same space, not across multiple tools and browser tabs.

Content Creation With Real-Time Refinement. You’re preparing a client presentation. You outline the key points with Claude, then ask it to create a branded deck using the Canva integration. The Canva interface appears in your conversation. As you review it, you can make design changes in real-time, adjusting colours, layouts, and graphics without leaving the conversation. The back-and-forth between content strategy and visual execution collapses into a single workflow.

Sales Outreach That Actually Scales. You’re building a list of potential partners. Using the Clay integration, you ask Claude to research companies and find contact information. The Clay interface appears with email addresses, phone numbers, company size, and funding data. You can then ask Claude to draft personalised outreach emails based on that data. All of this happens in a single conversation thread, with full context maintained throughout. What used to be a multi-tool, multi-hour process becomes a streamlined workflow.

What You’ve Actually Built

By connecting your tools to Claude, you’re not automating tasks that run on their own. You’re building an intelligent workspace where you can interact with all your business tools without losing context. You’re creating a system where context is never lost, and where you can move seamlessly between different applications without ever losing your flow.

The old way involved manually switching between multiple tabs and applications. You’d copy information from your project management tool, paste it into a Slack message, then jump to your analytics dashboard to pull a metric, copy that number, and paste it back into your status report. Every transition was an opportunity for error and a guaranteed loss of context. The workflow was fragmented, inefficient, and exhausting.

The new way gives you a single, unified workspace for all your tools. Context flows automatically between applications. When you’re discussing project status with Claude and it pulls data from Asana, analyses trends from Amplitude, and drafts a Slack update, everything stays connected. The context that lives in your head, the understanding of how these pieces fit together, is now reflected in how your tools work together.

Context Matters More Than You Think

Here’s the insight that most people miss about AI tools: the technology isn’t the bottleneck anymore. The bottleneck is context. ChatGPT might be powerful, but if you’re copying and pasting information into it, you’re manually managing the context. You’re the integration layer between your tools and your AI.

Claude’s approach is different. By bringing interactive tools directly into the conversation, Claude becomes the integration layer. It maintains the context across your entire workflow. It sees what you’re doing in Asana, understands the data from Amplitude, and knows what you’ve discussed in Slack. That continuous context is what transforms it from a helpful assistant into an operating environment.

This is why operators who understand their workflows, who know what context matters and how information flows through their business, are about to pull ahead. You don’t need to be a developer. You need to understand the playbook, the process, the context. That’s the skill that matters now.

What You Can Actually Do Next

Once you’ve connected your core tools, you can start building more sophisticated prompts. The key is understanding that you’re still driving the actions by asking Claude, but now you can do it all in one conversation without switching tabs.

Ask Claude to pull your latest Asana updates, check your key Amplitude metrics, and draft a formatted Slack summary for your team. All three tools will appear as interactive interfaces in your conversation. You can review the data, make adjustments, and send the message without ever leaving Claude. The tools are connected. The question is whether you understand your workflows well enough to know what to ask for.

Build a habit of using Claude as your command centre. Instead of opening five different tabs to check on project status, team communications, and business metrics, ask Claude to bring them all into one conversation. The more you use it this way, the more you’ll see where context was getting lost in your old workflow.

Get Started

Welcome to the new paradigm. AI Ops isn’t about replacing what you do, it’s about amplifying what you already know. Your context management skills, your process knowledge, your understanding of how work actually flows, these are the foundations that matter now.

Join a growing community of Project Managers, Operators, and Founders who are building the future of work. Selective insights and tutorials on AI Ops, delivered to operators who understand that context beats code.

Hey Friends 👋 Happy Tuesday

Here's your weekly dose of AI ways of working.

Keeping up with AI can feel like a full-time job, and it’s hard to know which resources are worth your time. The good news is, the teams actually building the AI are publishing their playbooks for free.

Google, OpenAI, and Anthropic are quietly releasing expert-level guides on everything from enterprise adoption to secure agent architecture. This isn’t third-party commentary; it’s the source code for your AI strategy, straight from the labs that built the models.

Before you spend time or money on another course, start here.

The Official AI Playbooks (9 Free Guides)

I’ve curated the best of them for you. No fluff, just the official documentation to get you started.

From Google:

•Prompting guide 101: A quick-start handbook for writing effective prompts that get you the right output from Gemini. Stop guessing, start structuring.

•Foundational LLMs & Text Generation: The deep-dive, 200+ page research book on how these models actually work. For when you need to understand the mechanics behind the magic.

•Agents Companion: Learn how Google thinks about agent architecture and evaluation. Essential for anyone tasked with building or deploying agents.

From OpenAI:

•AI In The Enterprise: A strategic guide to adoption, roadmap creation, and use case design. This is your blueprint for getting AI projects off the ground.

•A practical guide to building agents: The tactical guide to agent architecture and deployment. Move from theory to a working agent.

•Identifying AI Use Cases: A framework for filtering opportunities, mapping risk, and checking your organisation’s readiness. Stop chasing shiny objects and focus on what’s feasible.

From Anthropic:

•Building Effective Agents: Claude-specific flows and logic for creating reliable agents. A must-read for anyone building with the Claude API.

•Best practices for agentic coding: How to build secure and consistent applications on top of LLMs. Required reading for preventing prompt injection and ensuring reliable outputs.

These nine guides contain more actionable, credible information than most paid courses.

Which one are you reading this weekend?

Let me know in the comments.

Andres