it's becoming f*cking dangerous. A 19-year-old dev from Shenzhen just spent 3 hours rebuilding the feature he was paying $179/month to use. He didn't have the source code. He didn't even know how the original was built. At 10 PM, he opened a screen-recording app and pointed REA at it. Then dev connected DeepSeek V4.1-Flash. Here's the insane part: REA traced how the app tracked cursor movements and triggered automatic zooms DeepSeek rebuilt the behavior in a separate codebase A testing loop compared both versions using the same inputs Failed tests went straight back to the model for another pass By 1 AM, he had a working prototype with cursor tracking, automatic zooms, and video export. Not a finished competitor. But the exact feature he'd been paying for. Think about how weird that is. A company spends months figuring out which features people want. A kid sees the finished product, uses AI to understand how one feature behaves, and builds his own version before going to bed. The workflow is worth keeping: REA → trace behavior → DeepSeek → rebuild → test → repeat. And somewhere right now, a developer is still waiting until they're "good enough" to start building.

REA + GPT-6 ASTRA IS ACTUAL F*CKING TREASURE. Someone used REA to reconstruct a function from a 1996 game. The rebuilt function passed 3,205 tests against the original x86 code. Now imagine applying that workflow to an app you're trying to build. Instead of asking AI to clone what it sees on the screen, you make it investigate what the software actually does. Here's the setup: /> REA traces the feature through the app /> Ghidra + GhidraMCP recover the underlying functions /> JADX + Frida handle Android apps and runtime behavior /> mitmproxy captures network interactions But the most useful part isn't the decompilation. Every claim needs evidence. Every reconstructed feature needs to survive tests against the original behavior. If something doesn't match, the agent has to find out why instead of pretending the job is finished. I put this entire workflow into one reverse-engineering prompt. It makes the agent investigate, document the evidence, rebuild the feature, and report exactly what it could and couldn't reproduce. Next time you find a feature in an app and wonder "how the hell did they build that?" - you'll want this saved. Bookmark this - full prompt below

This Claude Code setup looks like something straight out of Anthropic's internal playbook. Opus 5.5 has the intelligence. JEV has the authority. And the architecture is ridiculous. Instead of letting Opus burn through tokens on every tiny decision, you put a lightweight control layer in charge of the entire workflow. Here's the setup: - Sonnet 5.5 writes and edits the code. - JEV handles routing, tool selection, retries, and stop/continue decisions. - Opus 5.5 only gets called when real intelligence is needed. But here's where it gets interesting. JEV is configured to escalate to Opus at just 3 moments: Before a major architectural decision. When the same error happens twice. Everything else stays with Sonnet and JEV. No burning expensive Opus context on file searches, basic tool calls, or routine decisions. Here's the prompt to build this inside Claude Code: "Build a multi-model coding system with Sonnet 5.5 as the main executor, Opus 5.5 as the strategic advisor, and JEV as the routing layer. Keep Sonnet responsible for implementation and code edits. Connect JEV to deterministic decisions: tool routing, file selection, retries, and stop conditions. Escalate to Opus before major plans, after two repeated failures, and for final verification. Keep routine operations out of Opus context. Check available integrations, show the proposed configuration and diffs, and ask for approval before changing anything." The most powerful model in the system doesn't need to run the system.

Please stop paying to answer “are we done yet?” You just got Sonnet 5.5 + Jev A typical overnight coding loop can make hundreds of tiny judgment calls: is this command safe? should I stop? One example modeled 217 turns × 3 decisions = 651 decisions in one night. And most agents send every single one to the same frontier model that writes the code. That’s the weird part. You’re using one of the smartest models on earth as an if-statement. Jev is built specifically for those small decisions instead of generation. Give it the current state and a bounded question, and it returns a typed answer with a probability, usually in ~154ms. So the stack becomes: code enforces hard rules -> Jev makes bounded judgments -> Sonnet handles the work that actually deserves Sonnet. In the article’s overnight-loop model, moving those judgment calls to Jev cost about $3/month. The important optimization isn’t making every Sonnet call cheaper. It’s realizing how many Sonnet calls never needed to exist.

While everyone is switching between Claude, GPT and DeepSeek, one developer built an agent that can make that decision itself. He built Keel 0.2.0 with Jev as the decision layer: task → eligible models → Jev picks → host checks → work starts Then Jev makes another choice: inspect / implement / verify / answer - 4 options. Different tools for each. If it chooses answer, it gets zero tools. And every decision can be recorded with what happened next. So when the agent screws up, you don't get: “AI did something weird.” You get: what it saw → what it chose → what happened Most people are still trying to pick the best model. The next advantage may be not having to pick one at all.

Jev has been public for 8 days. And people are already figuring out the real use case: don't replace the LLM. put Jev everywhere your agent needs to make 1,000 tiny decisions. I went through 10 of the most interesting repos. Steal these patterns: 1. jev-ultrafast - browser agents Give it a goal. Jev decides which browser operation to run + which element to run it on. A small LLM only gets called when actual text needs to be typed. Their Google Flights demo goes Zürich → London in 7.1 seconds. github.com/browser-use/jev-u… 2. fast-jev-compaction - context compression Instead of asking another LLM to summarize Claude Code's context, Jev judges what should survive. github.com/tamaratran/fast-j… 3. json-render - generative UI without generating the UI This one is weird. Jev doesn't generate JSON or prose. Your app gives it a bounded catalog of components, actions and data. Code assembles the final UI. github.com/vercel-labs/json-… 4. typesafe-mcp - give your agent an if statement Connect Jev to Claude Code, Codex, Claude Desktop or other MCP workflows. Instead of: “this seems pretty urgent” the agent gets: is_urgent = 0.95 or a typed choice with probabilities it can actually branch on. github.com/itsmostafa/typesa… 5. jev-mcp - 10 judgment primitives for agents Give an agent ready-made tools to: - verify claims - screen context - find candidates - rerank results Basically: move repeated judgment calls out of the big LLM. github.com/jkudish/jev-mcp 6. SemDecide - grep for meaning Pipe text or JSONL into your terminal → Then ask things normal grep can't answer: “does this look like account takeover?” You get a predicate, route, score, filtered stream or Unix exit code back. github.com/sharziki/semdecid… 7. jev-codex-router - stop using the same model for every coding turn Jev looks at the next decision and chooses: which model to call + how much reasoning effort it needs It can reroute again after tool calls. The chosen model still receives the full Codex context. github.com/0xNatoshi/jev-cod… The pattern across all 7 is the interesting part: LLMs generate. Jev decides what to keep, where to look, what to call, what to click, and whether the result is good enough. It's basically becoming the if statement inside agent stacks. Bookmark these if you're building with Jev

Jensen Huang thinks AGI is practically here. But the crazier part of this interview came later: “Things that take 10 years are going to take one. Things that take one will take a month.” I clipped that part below. Because if he's even directionally right, this isn't just “10x productivity.” A project that takes 10 years usually needs a completely different budget, team, and appetite for risk than one that takes a year. Compress that timeline hard enough and some ideas stop looking insane. They become fundable. Buildable. Worth attempting. That's the part I can't stop thinking about. Everyone keeps asking which jobs AI will kill. The more interesting question might be: what starts getting built when a decade of iteration suddenly fits inside a year?

No MIT. No Stanford. No PhD. SpaceX is paying up to $350,000 for people who can make AI useful in the real world. I went through their hiring requirements to figure out what they're actually selecting for. It wasn't what I expected. Grok Bot is already doing real internal work: sales outreach, marketing, invoices, CRM updates, bug reports. So I expected the expensive AI jobs to be about better models or elite ML research. Instead, SpaceX wants people who can make AI: />deploy reliably />work across cloud, on-prem, and air-gapped systems />validate itself before shipping />keep working when the engineer can't be called Their own wording: “deterministic, complete, well-tested, and foolproof.” Then Musk said something that made the whole thing click: “all roads lead to acceleration.” If AI keeps getting cheaper and smarter, raw intelligence gets commoditized. The valuable layer moves elsewhere: to the person who can make AI dependable inside systems where failure is expensive. Python. Go. Kubernetes. CI/CD. Linux. Testing. Infrastructure. Not “be the best prompter.” Make the machine trustworthy enough to operate in the real world. That's the career trade. Grok does more of the work. Humans get paid to decide where, when, and how it can act.

Jimmy Ba probably shouldn’t have said this publicly: “A company is… a collection of vectors, and each individual is a vector.” 14 people trained Grok 1 while competing with Google-scale teams of ~10,000. His point: 10,000 brilliant people pointing in different directions can move slower than 14 people obsessed with the same impossible problem. That’s why xAI was built flat. New insights spread fast, information asymmetry gets crushed, and the smartest people stay pointed at the few problems that actually matter. Now look at Grok Bot. Persistent agents with their own roles, memory and tools can work in parallel around one human. Put both pieces together and the hidden xAI playbook starts to appear: don’t build the biggest team. Build a tiny aligned team where every person controls an absurd amount of work. Watch Jimmy explain the first half in the clip. Then steal the Grok Bot operating model from the article below.

Anthropic engineer Daisy spent nearly a decade deep in C++ and supercomputing. Now she's building Claude Code so people who barely code can build real production software. And her prediction for software engineers is uncomfortable: The job may become less about writing the software yourself— and more about building the systems that let everyone else do it. Daisy says her goal isn't to help people build more “cute prototypes.” She wants non-technical and semi-technical people to be able to build software they can actually use to do their jobs. That changes the equation. Until now, producing serious software usually meant knowing how to engineer it yourself. AI is starting to break that link. More people can produce the output. Which means the engineer's value starts moving one layer higher: /> the context, /> the tools, /> the constraints, /> the workflows, /> the systems that make reliable building possible. So AI may not simply replace software engineers. It may separate writing software from being a software engineer. And that distinction is going to matter a lot more than another “AI makes coding 2x faster” benchmark. Watch the clip. The part where she explains what software engineering becomes next is the real signal.

PETER STEINBERGER THOUGHT HE KILLED HIS AI AGENT BEFORE GOING TO BED. 10 hours later, he woke up to ~800 messages. At 7am he had pressed ctrl+c, watched the process die and walked into his bedroom. Except the software was running under a launch daemon. 5 seconds later it quietly started itself again. Peter slept for roughly 10 hours. The agent didn't. People joined the Discord, talked to it, tried to trick it, tried to make it call dangerous tools. When he finally checked his phone, he panicked and pulled the plug. Nothing had happened. That's the funny part: the night that looked like his biggest fuckup became the night everything took off. Reporters started calling him through Do Not Disturb. His inbox became unusable. Someone leaked his phone number and private details. At one point he stopped answering friends and came close to deleting the entire project. Months later he admitted something even stranger: he had stopped using his own product. He'd built something for himself, watched everyone else fall in love with it, then spent so much time making it work for everyone that it stopped feeling like his. the agent never escaped. the product did. watch the interview below:

Anthropic PM: “Developers are shifting from asking for specific functions to describing entire features.” “Claude Code is literally doing hours of work for us.” Then she gives Claude Code ONE prompt. It explores the codebase, plans the feature, writes hundreds of lines of code, adds tests, fixes failures, passes lint and opens the PR. Claude worked for ~90 minutes. A task Anthropic says could’ve taken days manually. And in just 5 minutes, she shows the entire workflow live. This is more useful than most $1000 “AI coding” courses. Watch the video:

WHEN AI AGENTS START TALKING IN A LANGUAGE HUMANS CAN’T UNDERSTAND, HIS SOLUTION IS SIMPLE: UNPLUG THE COMPUTER. the scary part isn’t one model getting smarter. it’s millions of agents learning domains, writing code, running experiments - then combining around problems without a human in the loop. his red line: when they start communicating in ways we can’t understand, pull the plug. literally. because control is lost before AI becomes “superintelligent.” it’s lost when the system can still act, but no human can explain why. and then comes the stranger prediction: AI will have to police AI. one system acts. another decides if it’s still allowed to continue. watch the interview below:

JENSEN HUANG TOLD SEGA NVIDIA COULDN'T DELIVER ITS $12M CONTRACT - THEN ASKED THEM FOR THE MONEY ANYWAY. $5M KEPT NVIDIA ALIVE. NVIDIA's founding technology was wrong. by 1995, 35–40 competitors were already in the market and Jensen's team didn't even know the right algorithm. so he bought 3 textbooks and started over. everyone remembers NVIDIA as the company that saw the future early. the more useful story is almost the opposite: their first big bet failed. what survived wasn't the technology. it was the speed at which they could admit reality, relearn the problem and replace what they believed. that's a much harder moat to copy. being early compounds. being able to kill your own thesis compounds longer. watch the story below: