This is f*cking insane. Anthropic engineer:
"Prompting is basically over
95% of our engineers already run self-improving loops. The next move is graphs"
In just 10 minutes, she builds her entire Claude Code setup live, straight from an empty terminal
Empty Terminal → Agents → Loops → Graphs → Self-Improving System
Prompting was the old way. Engineering the system around the model is the new one
Save it and watch it today
then read the article below ↓
"Agent memory" isn't one thing. It's seven:
Working: what's in context right now
Semantic: lasting facts
Episodic: past events and how they went
Procedural: learned steps and workflows
Retrieval: looked up on demand (RAG)
Parametric: baked into the model weights
Prospective: reminders and triggers for later
Most real agents combine several of these. Save this for your next agent build.
Which one is hardest to get right in your systems?
Inspired by Neo Kim's original post.
#AIAgents #AgenticAI #LLM #RAG #AIEngineering
If you're under 46, I'll say this only ONCE.
CEO $NVDA Jensen Huang says normal people will be millionaires buying AI bottleneck stocks EARLY.
Here's 8 stocks that can still 15x:
1. $MRVL
THIS IS AN ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code.
The idea: run Opus 5.5 and three Sonnet 5.5 subagents, each one keeping its own memory for the job it's best at.
Less repeated explaining, because every task lands on an agent that can reuse what it learned about your repo.
You just launch Claude Code like this:
claude --model opus
here's my split:
→ Opus 5.5 runs the session, plans the work and applies the final fixes
→ Sonnet 5.5 handles implementation, debugging and diff reviews in separate contexts
→ memory: project gives each subagent persistent notes that survive between sessions
→ you stop burning Opus 5.5 context on explaining the same repo conventions again
Opus 5.5 only steps in for the big calls at three moments:
→ before a plan locks
→ when the same error shows up twice
→ before calling it done
Sonnet 5.5 builds. Memory carries forward. Opus 5.5 reviews.
persistent memory takes the same idea one layer down: the findings you keep rediscovering (which module, which test, which fix actually worked) go into each agent's memory, and its next run starts with its saved memory index
the full tree
> Opus 5.5 runs the main session and coordinates the work
> builder implements features on Sonnet 5.5 and remembers repo conventions
> debugger fixes failures on Sonnet 5.5 and remembers verified root causes
> reviewer checks the diff on Sonnet 5.5 and remembers recurring review patterns
> Opus 5.5 reviews the synthesized diff before sign-off
> each worker keeps project-scoped memory and checks old notes against current code
paste the tree and this prompt into Claude Code ↓
"Reconfigure my Claude Code setup around this tree:
1. Run the main session on Opus 5.5. Verify both model aliases resolve to 5.5 on my provider.
2. Create three Sonnet 5.5 subagents in .claude/agents: builder (implements features), debugger (fixes failures), reviewer (checks the diff). Flag a restart if this agents directory is new.
3. Set memory: project on all three. Check that auto memory is enabled; ask before changing that setting.
4. Add one rule to CLAUDE.md: delegate implementation, debugging and diff reviews to these subagents to keep the main context small. Sequence dependent work.
5. Tell each agent to consult its memory before working and save only verified, reusable findings afterward. Keep MEMORY.md concise, link detailed notes, and recheck stale assumptions against the code.
Show me every change as a diff first. No edits until I say go."
↳ https://t.co/5GFnjKH6q0
save it, it'll come in handy.
Faz uma semana que estou usando JEV + GROKbot e o resultado não poderia ser melhor.
tarefas saindo com mais qualidade, muito mais rápido e menos custo (importante agora que o Grok ficou mais caro)
Preparei o prompt pra quem quiser fazer o mesmo 👇
After Andrej Karpathy released autoresearch, where an agent runs experiments in a loop on its own, I packed his method into one prompt that turns Opus 5.5 into a graph and can carry almost any task to the finish.
→ writes a check that can actually fail, first
→ splits the task into parts
→ runs the independent parts in parallel
→ loops each one until it passes the check
→ sends back only the part that failed
→ turns every mistake into a rule for next time
→ calls you only for the step that can’t be undone
Throw it at Opus 5.5 with the task you’ve been putting off for a week, and you’ll see the difference in one run.
The full prompt is in the comments.
How to tune it for your own work is in the article below. Save it before it gets lost ↓
HOLY FFF*CK! A SPACEXAI ENGINEER JUST SHOWED WHERE TO GET 146 FREE GROK BOTS FROM THE GROK BOT TEAM AND USE THEM LIKE THE TOP 1% OF USERS
most people will install them blind. he shows the right way in 7 minutes.
how to use free grok bot templates, from his demo:
step 1: open the template link, nothing installs yet, you just get a preview
step 2: read the context and integrations first, treat it like installing software
step 3: hit "add to bot" and watch it install itself
step 4: reinstall the plugins it asks for, the official ones come bundled
step 5: add what's missing: API keys, MCP servers, custom scripts. these never come with a template
step 6: let it adapt, it's a recipe, not a clone, so your version will look a bit different
secrets and personal data are never included, so nothing leaks
where to get the bots:
marketplace: https://t.co/qyltLQzHJf
use cases: https://t.co/v1nvqB63Hj
save this and study the article below, it has ready-made grok bot configs you can copy 👇
Holy sh*t.. SpaceXAI web designer just shared a prompt for GrokBot that creates web design studio
just one prompt and you have a full web design studio inside your GrokBot
save now, then just send it to your GrokBot
THIS IS STUPIDLY F*CKING GOOD
Anthropic's own Claude Code playbook has a trick almost nobody uses.
The idea: stop running one giant session on a 300-file job. Opus 5.5 writes the plan once, then Claude Code runs headless, one fresh Haiku 5.5 session per file, 8 at a time.
No context rot, no 4-hour transcript, and you see the exact cost of every file.
You just run Claude Code like this:
claude -p "$task" --model haiku --max-turns 8 --output-format json
here's the split:
→ Opus 5.5 reads the repo once and writes tasks.txt, one line per file
→ Haiku 5.5 does one file per session with a clean context
→ Sonnet 5 only touches the files that come back FAIL
→ you read a cost column instead of babysitting a chat
You only look at three moments:
→ before the loop starts (read tasks.txt)
→ when the FAIL rate goes over 10%
→ before you merge
Opus plans. Haiku grinds. Sonnet cleans up.
JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split
the full tree
> Opus 5.5 writes tasks.txt: every file + the one rule to apply
> xargs -P 8 runs 8 headless Haiku 5.5 sessions at once
> each session: fresh context, max 8 turns, only Edit and git commit allowed
> each one must answer OK or FAIL, nothing else
> --output-format json gives you the result and total_cost_usd per file
> FAIL lines go to Sonnet 5 with the error attached
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Set up a fan-out run for this repo:
1. Use Opus 5.5 to write tasks.txt: one line per file that needs [your change], plus the exact rule to apply.
2. Write https://t.co/o9zohGK0sD: for each line, call claude -p with --model haiku --max-turns 8 --allowedTools "Edit" "Bash(git commit:*)" --output-format json, 8 in parallel with xargs -P 8. The prompt must end with: reply OK if done, FAIL if not.
3. Log file, OK/FAIL and total_cost_usd to results.csv.
4. Send every FAIL back through Sonnet 5 with its error, then stop.
Show me tasks.txt and https://t.co/o9zohGK0sD first. Don't run anything until I say go."
↳ https://t.co/7EzN9Eba0m
this is how you clear a week of refactors in one afternoon.
fiz esse vídeo *one fucking shot* com o Opus 5.5
como eu fiz
1. Pedi para o claude escrever um roteiro que contasse uma história a partir desse relatório da @a16z : https://t.co/4U2fCfHmoi
2. Para cada trecho do roteiro, pedi para ele descrever a cena visualmente
3. Pedi pra ele criar o vídeo a partir das descrições das cenas usando o eleven labs pra sintetizar a voz, e o meu site (https://t.co/clhgAJmOTQ) como referência visual
4. Ele trabalhou por 18 minutos e me entregou isso 👇
Acabou pros Motion Designers
E o dia não termina! Agora saiu também a versão 3.0 do meu AI-MEMORY, a versão com mais atualizações e novas funcionalidades!
Melhorias de performance, suporte ao novo Meta Muse Code, suporte como plugin de marketplace do Claude Code, e dúzias de coisas mais!
Veja tudo no site:
https://t.co/zOxTON54ZY
Pô, aí ele mitou @condzxyz
FUP no meu último post sobre edição de vídeo / Motion com claude
Conrado é uma das pessoas que mais manjam de produção de conteúdo com IA que eu conheço 🫡
The best UI components, ready to use.
https://t.co/Die3MteT8P — Beautiful UI components.
https://t.co/9xNyuP9I1u — Modern UI components.
https://t.co/YGkrnyzUIo — UI inspiration and components.
https://t.co/RJbb5W0a9K — Customizable chart components.
https://t.co/CcNQbady8t — Smooth UI animations
https://t.co/VGeH0XH9YD — Animated React components.
https://t.co/3Zr8fNNAw6 — Components for dashboards.
Save this for your next project.🔖
openai just released Decisions API, Jev-like "system 1" multi-modal model based on GPT6 Luna!
Each egg gets cropped and sent to OpenAI (~270ms latency) and returns P(clean, dirty, cracked).
One image crop consumes ~280 input tokens (~$0.03/1K imgs). @roboflow RF-DETR for detecting eggs
𝗧𝗵𝗲 𝟰 𝗟𝗮𝘆𝗲𝗿𝘀 𝗼𝗳 𝗮𝗻 𝗔𝗴𝗲𝗻𝘁 𝗦𝘆𝘀𝘁𝗲𝗺 𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗲𝗱
An agent burns tokens, declares the task complete, and then fails the tests. That is often an architecture problem, not a prompting problem.
When an agent underperforms, the usual reflex is to rewrite the prompt or switch to a stronger model. But many failures actually come from the system around the model, and different problems need to be solved at different layers.
𝟭. 𝗟𝗼𝗼𝗽: repeats until evidence says stop
The loop is the smallest unit of agency. The agent acts, checks the result, and either stops or tries again.
The important part is how completion is decided. A reliable agent should not stop simply because the model believes the work looks correct. It should stop when there is external evidence, such as a passing test, a successful build, a validated output or another measurable condition.
Without this verification loop, an agent can confidently declare success while the task is still incomplete.
𝟮. 𝗚𝗿𝗮𝗽𝗵: decides what runs next
A loop decides whether execution should continue. A graph decides where execution should go next.
It defines branches, retries, specialist-agent handoffs, fallback paths and shared state. Once a workflow has multiple possible routes, the graph makes those routes explicit, inspectable and controllable.
This is what turns repeated execution into a structured agent workflow.
𝟯. 𝗛𝗮𝗿𝗻𝗲𝘀𝘀: gives the model an operating environment
The model provides reasoning, but the harness determines what that reasoning can actually do.
It defines the tools, APIs, files, memory, permissions, context, logging and execution environment available to the model.
That distinction matters because model capability and agent capability are not the same thing. A model may understand exactly how to solve a task, but if the required tool, data source or permission is not exposed through the harness, the agent still cannot complete it.
A better prompt cannot compensate for a missing capability.
𝟰. 𝗠𝗲𝘁𝗮-𝗵𝗮𝗿𝗻𝗲𝘀𝘀: governs multiple agent harnesses
This layer becomes important when teams are using Claude Code, Codex, internal agents and specialised domain agents together.
Each may have its own tools, sessions, policies, permissions and execution environment. A meta-harness creates a common layer across them for orchestration, governance, isolation, shared policies and movement of context or workflows between different agents.
Omnigent is one open-source implementation of this layer, designed to provide a governed environment across different agent harnesses.
𝗧𝗵𝗲 𝗱𝗶𝘀𝘁𝗶𝗻𝗰𝘁𝗶𝗼𝗻 𝗶𝘀 𝘀𝗶𝗺𝗽𝗹𝗲:
Loop makes the work verifiable.
Graph makes the workflow structured.
Harness makes the model operational.
Meta-harness makes multiple agent environments governable.
A stronger model can improve reasoning, but reliable agents depend just as much on the architecture built around the model.