Shafraz

[Echo @ech0_speaks]

Anthropic Engineer Andrej Karpathy:

"The biggest mistake in AI right now: people are forcing agents to work instead of mastering the model first.

We made that mistake in 2016 at OpenAI. It cost us 5 years."

What Karpathy actually means:

step 1 → stop forcing your agent to do everything. Understand the model underneath first.

step 2 → demos are easy; products take a decade. Self-driving proved it. If you skip the foundation, everything breaks.

step 3 → the agent is not the product. The foundation is. Build that—and agents emerge on their own.

"You're building agents right now. You're at the forefront. Not OpenAI. Not DeepMind. You."

watch - bookmark

[Jamon @jamonholmgren]

I'm just going to dump my whole agentic setup out here, because I see too many people missing giant chunks of this and it's hurting them.

Here's what I have and recommend:

0. an AGENTS.md that is a router -- it sends the agent to the right skills, docs, tools

1. a standard workflow doc/skill customized to my needs ... (grab Matt Pocock skills if you don't already have something) ... I tag this in most sessions with `@/AGENT_WORKFLOW.md` and it pulls it in.

2. self-healing docs for every system, and agents are instructed to keep them updated ... I tag the ones I know I need, or let the agent find them through AGENTS.md ... I also provide a more detailed summary in the first 7 lines of every doc, so they're easily greppable to find the right thing, and this is documented in AGENTS.md

3. agents always run the app ... the agent should always actually run the app itself, and test its work and fix issues as it goes, especially if running autonomously / asynchronously

4. end-to-end tests and instructions to write more and keep up to date, and docs on how to write tests, what to avoid, and a list of all the tests and what they test in yet another markdown doc ... write and run targeted tests during implementation, improve and commit with work

5. custom linters at precommit hooks looking for any problems you run across, with `--fix` fixing the problems automatically, OR if that's not feasible, it shells out to a cheaper LLM like Composer 2.5 or Sonnet to fix the problems -- NOT just flagging them, but actually resulting in cleaned code

6. cross-agent review at each major point: research, plan, implementation, and wrap-up. I mean codex, claude, cursor, whatever -- but it shouldn't be the same model reviewing the same code. And specific docs for agent review, what to look for, how to approach it. Also, personas -- looking at the code from different perspectives, such as maintainability, code quality, security, performance, AI smells, domains (e.g. "financial services expert" or whatever) ... and each persona also "owns" a set of system docs too and keeps them up to date

7. agent traces / worksheets that track what the agent is doing each session. if the agent fails partway through, you should be able to hand this worksheet to another agent and it could finish the job. commit this worksheet with the work so it's all connected and easy to reference later (you will reference these later!!), also have the agent apply git tags that correspond to specific worksheet names so they're easy to find

8. automatic agent feedback to you at the end of the session, added to a doc that is also committed with the work, that you periodically ingest into an interactive session and improve your workflows

9. a tools or bin folder that contains python or bash scripts that the agent has skills to make to make its job easier (for example, I have an `agent_review` bash script that lets the agent kick off agent reviews via CLI without knowing each agent's particular incantations) ... docs on how to make scripts effectively, and instructions to constantly build these out more

10. periodic agent sweeps through recent commits, looking for problems / gotchas from a higher level across commits

11. a coding conventions doc that is just for specific coding conventions you want to see in the code base, your review agents use these a lot (but a lot of this should be in linters)

12. an agent loop / night shift skill for autonomous work, that lays out how the agent is to approach this, from an orchestration standpoint

13. a task queue that is accessible to the agent (mine is just a TODOS.md, but yours might be in Linear etc, with a CLI to fetch via API)

14. a periodic false-confidence test audit skill that looks for tests that aren't actually testing what you think they're testing, and that fix those

15. visual regression tests -- take screenshots, compare via tool and with agent visual review, commit with work (git lfs useful here) or at least push into the PR

16. automatic performance benchmark tests that notice when performance degrades

17. performance profiling tools that can be used by agents for targeted benchmarking, trying new techniques, comparing outputs, and comparing profiles

18. end-of-shift full validations, including running all tests, performance, agent reviews, sweeps, everything -- when you return, it's all as pristine as it can be

If you have all this, your agentic coding experience is going to be very different than dry prompting and manually guiding it toward the right thing every time.

[Raytar @Raytar]

4 Anthropic engineers. One hour.

The best prompting lesson on the internet, and it's free.

14:12 - Real prompts from inside Anthropic
32:33 - The fix that saves your prompts
59:44 - How to give Claude the right context
1:07:59 - The prompt that does your job while you sleep

Spend one hour with the people who write the prompts inside Anthropic.

Then read the step-by-step guide below.

[Krishna Agrawal @Krishnasagrawal]

Andrew Ng just dropped a 3-hour course on how to become an AI Engineer in 2026:

• 00:00 - How to build agentic AI systems
• 04:25 - Future of AI engineering
• 23:38 - AI Prompting full course
• 2:52:17 - Creating an app with AI in 30 minutes

This 3-hour watch could replace 10 AI engineering courses on the internet.

Watch it today, then read how to run a self-improving system in the article below.

[Rahul @sairahul1]

Google Brain founder, Andrew Ng:

"100% of my tasks are done by ai agents, self-improving loops are next.

Give it 3-6 months and prompting is gone."

32 minutes of clear explanation on building loops from scratch.

Worth more than any $500 agentic course.

Watch it, then read the full guide below.

[MIKE @mikenevermiss]

THIS IS THE CLEAREST 7 MINUTES ON HOW AI LOOPS ACTUALLY WORK

at 4:19, he shows a real loop running live.

an experiment starts with 48 different options and keeps refining itself until only the best one is left.

nobody touches the keyboard.

a loop isn’t just a longer prompt.

it runs, checks its own output, and if the goal hasn’t been reached, it runs again.

the important part is giving it a finish line.

“make it better” never ends.

“all tests pass” is something it can verify, so it knows exactly when to stop.

then a second agent reviews the result, because the agent doing the work will almost always think it’s finished too early.

same prompt.

just wrapped in a loop that keeps going until the job is actually done.

start with one repetitive task you already hate doing.

the full guide is below.

[Mr. Buzzoni @polydao]

THE ANATOMY OF A LOOP RUNNING WHILE YOU SLEEP

an anthropic engineer runs autonomous code cycles on a closed laptop using a five-file folder

this loop architecture opens pull requests and runs tests without a single chat prompt:

> contract.md - defines the shift rules and operational boundaries
> schedule.yml - triggers the cron events to launch the next cycle
> rubrics/ - stores the graders to evaluate output quality before staging
> state/ - logs active checkpoints to recover from system crashes

the window to run Fable 5 reasoning loops under the $20 subscription closes on July 12th

build your autonomous pipelines now before it shifts to expensive API billing

grab the full folder blueprint below 👇

[AI Guides @free_ai_guides]

Your agent learns from two signals: its own traces and what the user does to fix its mistakes. Most teams keep the trace. The fix goes uncaptured.

This map breaks down the self-learning loop in 4 parts: two signal sources, three memory types (fact, case, rule), where lessons live, and how to close the feedback loop.

Save the map, then read the guide on loop engineering below.

[Yero @Yerocode0]

Google acaba de soltar un curso de solo 1 hora sobre Ingeniería Agentiva que destroza a la mayoría de cursos de pago 🔥

Timestamps:
00:00 → Cómo construir tu primer agente de IA
08:24 → Memoria de agente (corta, persistente y larga)
28:34 → Bucles agentivos y agentes de larga duración
40:04 → MCP vs API (esto solo ya vale la pena)
1:00:22 → Sistemas multiagentivos

En 60 minutos aprendes más que en 10 cursos pagos. Míralo hoy. Luego lee el artículo y construye un sistema agentivo que se auto-mejora solo.

¿Lo vas a ver ahora o lo guardas para “después”? 👀

[Phosphen @phosphenq]

Anthropic just released a 3-hour masterclass on how the best companies in the world, from Cursor to Spotify, build with Claude:

00:06 – how Cursor built its cloud agents
14:30 – how Lovable vibecodes at scale
45:22 – Spotify: why coding is no longer the constraint
1:42:56 – building AI-native, from Cognition to Harvey
2:09:18 – enterprise scale: mondaycom, Doctolib, Delivery Hero
2:38:11 – how one team went from 1 person to 80

This 3-hour watch will replace 10 paid AI engineering courses on the internet.

Watch it today, then go build your own agents in part 2, below.

[Kanika @KanikaBK]

Omg.. this can't be true...

I kept building AI agents on my eventually list because everything I read made it sound like a six month project requiring a technical background I did not have.

One Reddit thread changed that by saying the one thing nobody had said clearly: pick the smallest possible problem and finish it completely before you try to build anything impressive.

MY ARTICLE IS THE CLAUDE CODE VERSION OF THAT LESSON.
Working agent - Under one hour - Zero coding.

Full guide below.

[kaize @0x_kaize]

Claude Code just dropped "Getting Started with Loops"

This is their first official document about Loop Engineering.

Spoiler: prompt engineering didn't survive.

Here's the full guide in one post:

1. Turn-based

Every prompt you send already runs as a loop: Claude gathers context, takes action, checks its own work, and repeats until it decides the task is done or realizes it needs your input.

2. Goal-based

You define what "done" looks like with /goal, and Claude keeps iterating toward it. Every time it tries to stop, a separate evaluator model checks your condition - if it's not met, Claude gets sent back to work until the goal is reached or the turn limit hits.

3. Time-based

This is the /loop command: нou set an interval and a prompt fires on schedule. For example, every 5 minutes Claude checks your PR, addresses review comments, and fixes failing CI.

4. Proactive

Here you set up an event once, and the loop triggers itself whenever that event happens - with zero human input.

Anthropic also shared optimization advice - and this part matters most:

- Loop quality depends on system quality.
- Tokens are the real cost

None of this is magic. It's the same familiar parts - /goal, /loop, Skills, Hooks - composed into systems that run without you.

I built exactly that kind of system in my article:

Loop that wakes up at 6 AM, finds work on its own, reviews itself, and leaves ready PRs for you. Step by step, from SKILL(.)md to cron trigger:

[Movez @0xMovez]

Andrew Ng just dropped a 3-hour course on how to become an AI Engineer in 2026:

• 00:00 - How to build agentic AI systems
• 04:25 - Future of AI engineering
• 23:38 - AI Prompting full course
• 2:52:17 - Creating an app with AI in 30 minutes

This 3-hour watch could replace 10 AI engineering courses on the internet.

Watch it today, then read how to run a self-improving system in the article below.

[ClaudeDevs @ClaudeDevs]

https://t.co/v694m8Eaj6

[Future Stacked @FutureStacked]

Anthropic just dropped 5 workshops on building self-improving agentic systems from scratch:

00:00 - Ship your first Claude agent
36:44 - Build memory for Claude agents
1:05:06 - Make your agent autonomous
1:26:46 - Set up a proactive agent
2:03:35 - self-improving agents (tools,skills)

These 3-hours of free Claude workshops will replace 10 paid agentic courses.

Watch today, then read article below on how to us Fable 5 like the Top 1%

[Khairallah AL-Awady @eng_khairallah1]

Anthropic engineer:

"You're not supposed to prompt Claude. You're supposed to build a system that prompts itself."

In 45 minutes she shows exactly how to build an agent that improves itself.

Most people are still doing all of this by hand.

Watch the session, then save the guide below.

[Codez @0xCodez]

Anthropic just dropped 5 workshops, revealing the latest capabilities of Fable 5:

• 00:00 - deep look into Fable 5
• 11:22 - Fable 5 and the capability curve
• 30:54 - building managed agents with Fable 5
• 44:29 - real use cases of Fable 5 by teams
• 57:43 - how to deploy agents with Fable 5

These 1-hour of sessions will replace 100 articles on how to actually use Fable 5.

Watch them today, then read the best practices from the sessions in the article below.

[Boris Cherny @bcherny]

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

A healthy team needs a mix of these, depending on the product:

- A product that is new and pre-PMF needs people that are strong at 1+2+3
- A product that is growing and has found PMF needs 2+3+4 and some 5
- A product that has strong PMF needs 3+4+5 and some 2

Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

[Codez @0xCodez]

https://t.co/eJB3TgyJwV

[Agent Native @agentnative_]

Codex update: “Record and Replay” is a new plugin that lets you record any repetitive on-screen workflow once and instantly turn it into a reusable skill.