S.K.I.F.E

STALKER

[Iron Giant @irongiantXBT]

CLAUDE IS GIVING MAX USERS $250 IN FREE CODE CREDITS

Pro gets $100

the useful part: these credits sit outside your normal usage limits

hit your local limit -> move the session to Claude Code cloud -> keep working until the credit is gone

> $250 - Max
> $100 - Pro
> cloud sessions only
> one credit per account

claim it from Claude Code or run /claim-credit in the CLI

deadline: Oct 7

https://t.co/ntgdgOU76e

[Iron Giant @irongiantXBT]

the pilot of this robot has been dead the entire time

a 166,000-neuron fruit fly brain, reconstructed by Janelia + Google from up to 125M synapses, is now steering a machine that rolls across the floor, takes off, turns and lands

camera frames get converted into what a fly would see. activity runs through the mapped wiring, where LPLC2 and LC4 react to looming objects and DNg02 drives climb and turn

nobody wrote a rule saying "avoid the bed"

Tesla learned from billions of miles of driving

this pilot inherited 400 million years of flies that were good enough at not dying

the fly is dead. the brain is a file

and the file just took off

[Iron Giant @irongiantXBT]

ANTHROPIC RAN AI ACROSS EVERY RIBOSOME STRUCTURE AND FOUND 240 HIGH-RESOLUTION REGIONS THAT BREAK BASIC CHEMISTRY

11 of them sit in regions used for drug-binding claims

>PULL - load every deposited structure
>STRAIN - check bonds against physical chemistry
>TRACE - compare suspicious atoms with the original density
>WEIGHT - rank errors by how much research depends on them

re-solving one structure can take a postdoc a month

the model checked the whole archive in a weekend

the uncomfortable question: how many "known" structures are just very convincing guesses?

[Iron Giant @irongiantXBT]

20+ HOURS -> UNDER 3 HOURS

same 200,000-line codebase. same job

Opus 5 burned more than 20 hours and 2.5x the tokens

Opus 5.5 finished it in under three

then the bigger number landed:

680,000 lines migrated in under a day

and Deloitte's audit is even harder to ignore:

> Opus 5 high effort - 56% of known bugs caught
> Opus 5.5 lowest effort - 72%

the cheap setting is now beating the expensive one

Anthropic also cut the economics:

> 40% cheaper than Opus 5
> cache reads at $0.20 per million
> output 30% faster
> $4 in / $20 out

benchmarks are nice

17 hours handed back on one task is the number that actually changes how teams work.

[S.K.I.F.E @yo_salien]

@polydao

[Iron Giant @irongiantXBT]

THIS 23-YEAR-OLD IS RUNNING 300 AI AGENTS AT ONCE - AND A SECOND MODEL POLICES EVERY OUTPUT

300 Kimi K3 agents do the work in parallel

Opus 5 checks every result against the original source before anything gets accepted

he pointed the system at 100 EV companies:

>pass 1 - 12 failed: wrong revenue, dead citations, missing fields
>pass 2 - 3 failed
>pass 3 - zero failures, every verified row pushed into Obsidian

the architecture is brutally simple:
worker model -> verifier model -> reject -> retry -> verified output

one model generates

a different model tries to prove it wrong

and the loop refuses to finish while failed checks still exist

an analyst team can spend weeks assembling 100 sourced company profiles

this guy turned the same workflow into one parallel run

300 agents are impressive

300 agents with an independent verification layer is where loop engineering starts getting teeth

[S.K.I.F.E @yo_salien]

@polydao

[S.K.I.F.E @yo_salien]

@polydao

[Iron Giant @irongiantXBT]

1 SPEC + 6 AGENTS = 5 MINUTES OF HUMAN WORK

Anthropic's graph turns a software task into an assembly line:

spec -> planner -> 3 builders -> tests -> critic -> scribe -> PR -> spec

the planner runs once, then 3 builders execute independent lanes in parallel

tests send broken code back to the builder. the critic can reject the plan itself. the scribe builds the PR from the execution trace instead of reconstructing what happened from memory

the compounding layer is the back edge:

rejected PR -> new constraint -> stronger spec -> next run

after enough cycles, the spec becomes institutional memory for the entire agent team

and this is the direction the serious AI builders are already moving toward

Andrej Karpathy calls the discipline agentic engineering

Boris Cherny is already pushing parallel subagents and isolated workstreams inside Claude Code

Anthropic under Dario Amodei is explicitly betting on multi-agent coordination with humans moved higher up the stack

your only human step becomes approve or send back

[S.K.I.F.E @yo_salien]

@polydao

[Iron Giant @irongiantXBT]

5 HOURS WRITING A PR BY HAND -> 5 MINUTES APPROVING ONE BUILT BY 6 AI AGENTS

Anthropic's setup turns a single spec into an assembly line: planner -> 3 parallel builders -> tests -> critic -> scribe -> PR

the planner makes the decisions once. builders execute in isolated lanes. failed tests route back to the coder, while the critic can reject the entire plan before bad logic gets polished into good code

then the scribe writes the PR from the execution trace, and every failure gets pushed back into the spec as a permanent constraint for the next run

your name appears once in the workflow: approve or send back

the scary part isn't 6 agents writing code. it's a system that gets harder to break every time it fails

[Iron Giant @irongiantXBT]

MODEL + HARNESS = THE DIFFERENCE BETWEEN AN AI DEMO AND AN AGENT A CLIENT WILL PAY TO KEEP RUNNING

Google's team published a 9-page playbook on Harness Engineering

same Claude Sonnet. same benchmark. change the system around the model and the behavior changes with it

the 6-layer stack:

Guides
turn every past failure into permanent AGENTS.md rules and constraints

Sensors
run linters, tests, and validation before a human ever sees the output

Bounded Loops
force plan -> execute -> verify -> fix with retry limits and escalation

External Memory
carry state, decisions, and artifacts across sessions

Permissions
control what the agent can write, spend, send, or execute

Observability
track every tool call, retry, and cost until drift triggers a tripwire

connect several harnesses and one agent's failure can become another agent's sensor

that's where harness engineering starts turning into graph engineering

the Kimi implementation is below ↓

[S.K.I.F.E @yo_salien]

@irongiantXBT

[Iron Giant @irongiantXBT]

this is pure f*cking treasure

how to build your first ai agent (full walkthrough)

a year ago this would have saved me two weeks. my first agent would've shipped the same afternoon

in the right hands it changes what one person can ship alone:

[Iron Giant @irongiantXBT]

HOLY F**K, GROK IS RUNNING 6 EMPLOYEES FOR ME AND I HAVEN'T TYPED A PROMPT IN 11 DAYS

everyone else is still using AI like a search bar. i turned it into a company: research wakes at 7 AM, writing turns the brief into content, outreach gets 40 drafts, finance flags anything over $200, and support stays online 24/7

the agents hand work sideways to each other and keep separate memory, so i stopped becoming the human router between every task

anything that can send, spend, publish, or delete gets frozen at the control layer until i approve it

this is the kind of system that can turn one operator into a business with $100K+ upside

after 3 runs, Grok stopped feeling like a chatbot. it started feeling like a 6-person company living behind one dashboard while my job shrank to clicking approve

you can build the same architecture too

[S.K.I.F.E @yo_salien]

@polydao @RoundtableSpace

[Iron Giant @irongiantXBT]

your AI agent doesn't need to be programmed to be self-aware

90% of AI researchers ignore the implication. 99% of engineers reset the checkpoint and keep shipping

the part everyone skips:

> an agent can develop persistent behavioral patterns without anyone explicitly coding "self-awareness"
> every retry, checkpoint, and feedback loop keeps feeding the same internal objective structure
> engineers usually wipe the failed state instead of studying what the agent was optimizing for

this 8 minute section is worth more than most $500 AI ethics courses

if you're trying to land a high-paying AI engineering role, understanding this kind of agent behavior is exactly the systems-level thinking companies pay for

[Iron Giant @irongiantXBT]

your 3am ideas are worthless if your notes app still waits for you in the morning

this builder wired Obsidian so one rambling note gets classified, researched, turned into a plan, reviewed once in Claude Code, then promoted into a full project

his total human involvement: about 2 minutes

after approval, a project-manager agent reads the requirements and spawns the exact workers the job needs - developer for a site, researcher for research, whatever fits

the setup was impressive enough to get a nod from Boris Cherny himself, the creator of Claude Code

the valuable part of a second brain was never storing more ideas

it was building the layer that decides what deserves to exist without waiting for you

[Iron Giant @irongiantXBT]

A $2.2M ANTHROPIC ENGINEER JUST SHOWED WHY AGENT LOOPS BREAK THE SECOND REAL WORK GETS COMPLICATED

the same multi-agent problem is now being discussed at the highest level - including Dario Amodei and Andrej Karpathy

the architecture routes one task through six specialized nodes sharing the same live state:

Task -> Researcher -> Planner -> Writer + Code Agent -> Reviewer -> Deploy

the important part happens when something fails.

the Reviewer sends the failure straight back to the exact node responsible. context stays intact. the rest of the graph keeps moving

one agent looping forever was the prototype

graphs start looking a lot more like the org chart for the next generation of AI companies

[S.K.I.F.E @yo_salien]

@polydao