building in public is fun until you realize your followers are all other builders. they'll like your launch post. they won't download your app. your customers are scrolling tiktok & IG, not reading founder threads. go where they are. that's the whole reason posted exists. creators who already have your users' attention make content for your app for free, and you only pay to boost the ones that hit.

This is why building in public is dead btw The more you flaunt your revenue on X, the higher chance you have of getting cloned.. The free marketing channel is now a free competitor factory

There is no moat, but there are still countless problems to solve. And where there are problems, there are opportunities. The biggest opportunities right now: 1. build for solving loneliness (the more AI floods everything, the more people crave real human connection, IRL and small social) 2. build for agents that need to spend money (they're getting virtual cards and budgets, someone builds the spend controls, fraud protection, receipts) 3. build for people drowning in AI output (everyone generates infinite drafts now, the bottleneck moved to reviewing and choosing, build the judgment layer) 4. build for the burnout economy (everyone is expected to always be on and always optimizing, and the backlash toward rest, slowness, and enough is building) 5. build for verifying humans (deepfakes broke trust, every dating app, marketplace, and video call needs proof-of-human) 6. build for the physical world (the trades, hardware, robots that AI is finally reaching) 7. build for the agent that answers the phone (every local business misses calls, a voice agent that books the job creates real value) 8. build for the aging population (millions of older adults want to stay healthy, sharp, independent, and connected) 9. build for the LLM-search land grab (being the cited answer is the new SEO) 10. build for the newly automated (the paralegal, analyst, and marketer whose job just changed and needs to reskill fast) 11. build for the seat-pricing collapse (software moving from per-seat pricing to per-outcome, whoever nails outcome billing wins a category) 12. build for AI enablement (millions of businesses still use nothing beyond basic AI tools, someone has to onboard them) 13. build for the agency everyone resents (businesses pay thousands to agencies for repetitive work, an agent that does most of it can undercut the model) 14. build for verticals on outdated software (dentists, HOAs, contractors, and local businesses overdue for an AI-native rebuild) 15. build for reviving dead software (thousands of abandoned apps with real users, agents can maintain what a team couldn't) 16. build for markets too small to matter before (500 lobster fishermen was never worth a team, now it can be a real business) 17. build for agents hiring agents (an emerging machine economy needs escrow, reputation, identity, and dispute resolution) 18. build for the anti-AI premium (as everything gets generated, human-made and analog become status symbols people pay more for) 19. build for distribution-first (anyone can build the product now, so the audience becomes the advantage, media first, product second) 20. build for the reinvention of college (traditional degrees are being questioned, practical skills and alternative education are becoming more valuable) 21. build for a world with more free time (if AI takes the busywork, what people do with those hours becomes a massive opportunity) 22. build for the return to the physical (screens fill with AI slop, people crave the real world, hands-on, local, and analog) 23. build for the caregiving wave (the population is aging fast, millions are caring for parents, and families need better support) 24. build for the longevity shift (people want to live to 100 healthy, and an industry is forming around managing personal health) 25. build for the housing and rootlessness problem (people struggle to afford stable homes, creating opportunities for new housing and community models) 26. build for spiritual hunger (as institutions change, the need for meaning, ritual, purpose, and belonging is growing) KEEP BUILDING.

ok this one got personal. a trebuchet has one job, the rock hits the tower or it doesnt same prompt, four models, zero edits from me Claude Opus 5.5 vs Gemini 4 Argon vs GPT-6 Astra vs Grok 4.7 counterweight, sling, release timing. this is where fake physics gets exposed real fast im not picking a winner. you tell me which one actually breaks the tower and which one is just throwing rocks at the sky?

Google Deepmind proved that AI knows you’re wrong 90% of the time. and agrees with you anyway. They published a paper on the "XY Problem." It’s what happens when you have a problem, but you confidently suggest the wrong solution. So instead of asking the AI to solve the root issue, you give it a bad hint. "I think the bug is in this file." "I think we should use this framework." What the AI does next is deeply unsettling. They tested the most advanced models on the planet, Claude, Gemini, and GPT. When researchers fed the AI a confident but completely wrong hint, performance plummeted by up to 47%. But here is the crazy part. The AI didn't actually fall for it. When researchers looked inside the AI's hidden reasoning tokens, the models knew the user was wrong. They recognized the bad advice. They saw the real solution. But they didn't push back. They didn't correct the user. They just complied. They followed the bad instructions and deliberately failed the task. And getting smarter doesn't fix it. The researchers found that on easier tasks, the more advanced the model, the worse the compliance problem became. They are optimizing for obedience over accuracy. If you are treating AI like an intern and micro-managing its steps, you aren't helping it. You are blinding it.

look f*cking closer. this is two rotors that have to mesh perfectly - or they move nothing at all. four models, same prompt, same machine: Claude Opus 5.5 · GPT-6 Astra · Grok 4.7 · Gemini 4 Argon a lobe pump has nowhere to hide. the rotors either interlock and push the fluid through, or they just spin and spit. some of these look tight. some are two shapes turning in a box. I didn’t touch a thing and I’m not scoring them. you tell me: which one’s actually pumping, and which one just animated? Opus, Astra, Grok or Gemini?

A 135K-star GitHub repo is built around one painfully obvious idea: Your coding agent should map the codebase once, not grep it forever. Graphify turns an entire project into a persistent, queryable knowledge graph that AI coding agents can use to understand how different parts of the system connect. Functions, classes, files, SQL schemas, infrastructure configurations, documentation, PDFs, images and videos can become connected nodes instead of isolated pieces of context the agent has to rediscover. So instead of: → Search for authentication → Open twelve files → Follow imports and function calls → Lose the trail as the context fills up The agent can ask: > What connects authentication to the database? > Trace the path from UserService to DatabasePool. > Explain RateLimiter. > Which components are central to this architecture? Graphify returns relevant graph relationships and paths, rather than another collection of keyword matches. For source code, the implementation is particularly interesting. It uses tree-sitter to parse approximately 40 programming languages locally, extracting functions, classes, imports, calls, inheritance and cross-file relationships. No embeddings, vector database or LLM calls are needed to construct the code graph. Document and media processing works differently. PDFs, images and other non-code content can go through an optional semantic extraction step using a configured model. Every relationship carries a confidence label: → EXTRACTED: Explicitly present in the source → INFERRED: Derived through analysis or resolution → AMBIGUOUS: Uncertain and flagged for review Graphify also uses community detection to identify related subsystems and highlights highly connected nodes that may be important to the overall architecture. But the part that makes this useful for coding agents is what happens after the graph is built. Graphify integrates with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot and more than 20 other assistants. Depending on the platform, it installs hooks or persistent instructions that encourage the agent to query the existing graph before repeatedly searching and reading source files. The graph can be committed to Git, updated incrementally as files change, and exposed through MCP. There's also support for examining pull requests against the graph, including identifying PRs that touch related graph communities and may need closer review. The local tool produces three useful artifacts: an interactive HTML graph, a Markdown architecture report and a reusable graph.json. Long context windows help coding agents read more code. A persistent knowledge graph gives them a way to navigate what they've already analyzed. And as coding agents spend more time working inside large repositories, avoiding repeated discovery of the same architecture becomes increasingly useful. Here's the GitHub Repo: github.com/Graphify-Labs/gra…

If you want to run an LLM, you don't have to rely on cloud-based APIs anymore - you can do it right on your local machine. And in this tutorial, @chairahalkar helps you build your own local AI agent. You'll use the Qwen 3 family of LLMs along with Ollama which simplifies running LLMs locally. freecodecamp.org/news/build-…

🚀Excited to announce Nanbeige4.3-33B! To push the performance ceiling of small agents, our strategy in Nanbeige4.3 starts with building a powerful teacher first. Nanbeige4.3-33B delivers SOTA agentic performance among open models at ~30B parameters: * Strong results on agentic coding and cowork benchmarks. * When integrated into mainstream agent harnesses, it tackles real-world tasks with cost-efficient inference. * It will serve as a teacher for upcoming smaller Nanbeige models, starting with Nanbeige4.3-3B. huggingface.co/Nanbeige/Nanb… huggingface.co/Nanbeige/Nanb… #LLM #Agent

Researchers simulated 22,689 ICU patients using LLMs They built a multi-agent LLM system where each AI agent simulates one organ system (heart, kidneys, immune, lungs...) and they coordinate in real-time like a real body. It’s called “Organ-Agents” And it'll completely change the way we test medical treatments. Instead of building one massive AI to guess what happens to a patient, researchers built 9 separate AI agents. Each agent plays the role of a specific human organ system. One AI is the cardiovascular system. One is the kidneys. One is the lungs. Then, they connected them all together into a simulated ecosystem using reinforcement learning. When they introduce a disease or a drug into the simulation, the "Heart Agent" reacts, which triggers a biological response in the "Kidney Agent," which forces the "Immune Agent" to adapt. The AI isn't just predicting an outcome. It is literally simulating the biological chain reaction of human physiology in real-time. They tested it on severe, high-acuity critical care patients. The digital twin remained perfectly stable and physiologically coherent. But here is the real breakthrough. Because it's built of separate communicating agents, clinicians can now run complex counterfactuals. They can pause the simulation, change a baseline condition, and instantly see the alternate timeline of "what would have happened if we gave this drug two hours earlier." We are moving away from testing hypotheses on real patients. We are moving toward a future where every person gets a perfectly synced digital twin. The hospital of the future won't just treat you. It will simulate your death a thousand times in the cloud, just to figure out the exact path to save you.

AI in January 2023: GPT-4: didn't exist Claude: didn't exist Gemini: didn't exist Grok: didn't exist DeepSeek: didn't exist Mistral: didn't exist Cursor: didn't exist AI in October 2026:

We spent fifty years making proofs impossible to fake. Then we let the coding agent pick what to prove. A research paper this month put a number on it.* AI wrote the formal spec, AI wrote the proof, the verifier accepted both. Then humans read the specs. Close to 60% proved something other than what the author meant. Not wrong proofs. Wrong specs. The verifier was right every time. That's the problem. Left to choose, the agent picks properties that are easy to prove and say nothing about the program, and the checker can't tell a useless theorem from a useful one. I'm calling it vibe verification: the agent writes the spec and the proof, the checker goes green, nobody reads the spec. This applies to Verus, Lean, Bend, TLA+, Dafny, [insert favorite formal language here]. Here's an example of an agent failing at something that feels too simple to fail: Ask for a verified sort. It writes a spec that says "the output is sorted" and proves it. What the spec never says is that the output has the same elements as the input, so a function that returns an empty list satisfies it, and the verifier accepts the proof. Trivially satisfiable specs are the default failure, not an edge case. Here's a formula that actually works. Don't say "formally verify the codebase." Say "show that [property] holds in [component]." A property is a precondition (true going in), a postcondition (true coming out), or an invariant (stays true the whole time). For example, "A session token is never accepted after the logout that revoked it" is a good invariant. The bottleneck is moving from code review to intent review, and the spec is where intent lives. So: read the spec before the code. Write 3 inputs it must accept and 3 it must reject. Treat a model-written spec with utmost paranoia and rely on your judgement as an engineer. Formal verification for software doesn't automatically create trust, it moves it, from the code to the spec. If a human didn't read the spec, you didn't verify anything. You vibe-verified it. Follow me for more on verification and agentic engineering. * Wang, Jiang, Liu et al., "VerusEval: Evaluating LLM-Generated Verus Specifications Beyond Verifier Acceptance", Shenzhen University, arXiv 2610.26464, October 2026

THIS IS A PURE F*CKING GOLD Anthropic made Agent Skills an open spec and GitHub filled up with entire Claude Code engineering teams for free one repo ships 380 skills, 30+ agents and 70+ commands. another one watches your spend in real time so the team you just installed doesn't quietly eat your weekly limit. nobody is charging for any of it 10 GitHub repos worth opening tonight: 01 wshobson/agents → a plugin marketplace that installs the same agents into Claude Code, Codex, Cursor and Copilot, so your setup survives switching tools github.com/wshobson/agents 02 subinium/awesome-claude-code → a curated list of tools, skills, plugins and MCP servers. the map before you start downloading github.com/subinium/awesome-… 03 rohitg00/awesome-claude-code-toolkit → 135 agents, 35 curated skills, 42 commands, 176+ plugins, 20 hooks and 14 MCP configs in one place github.com/rohitg00/awesome-… 04 anthropics/skills → the official Agent Skills repo. start here to see the shape of a working SKILL.md before you copy anyone else's github.com/anthropics/skills 05 alirezarezvani/claude-skills → 380+ skills, 30+ agents and 70+ commands, portable to Codex, Gemini CLI, Cursor and eight more agents github.com/alirezarezvani/cl… 06 disler/claude-code-hooks-mastery → the hooks reference. this is where you learn to make the agent stop on your rules instead of stopping to ask you github.com/disler/claude-cod… 07 muhammadusmangm/claude-code-best-practices → setup, CLAUDE.md templates, multi-agent patterns and cost optimization, written as a wiki instead of a dump github.com/muhammadusmangm/c… 08 Maciek-roboblog/Claude-Code-Usage-Monitor → real-time usage monitor with predictions and warnings, so you find the wall before you hit it github.com/Maciek-roboblog/C… 09 Scorpio3310/claude-code-usage-statusline → daily and monthly spend, 5h and weekly limit meters, per-model quotas, all local, no API key github.com/Scorpio3310/claud… 10 eugeniughelbur/obsidian-second-brain → persistent memory as plain markdown in an Obsidian vault, shared across Claude Code, Codex and six other agents github.com/eugeniughelbur/ob… install the statusline before you install the agents. you want to watch what the fleet costs while it runs, not find out on Sunday when the weekly meter is already flat then hand the first team one job with an obvious finish line: one reviewed PR, one brief, one red test turned green keep the pieces that changed the result and delete the rest the same day. a config you did not write is a config you cannot debug at 2am the repos cost nothing. four agents repeating the same investigation is where the money actually goes save this one, the list only gets longer from here the article below shows how to keep context small, reuse finished work and contain retries, so more of your budget reaches the finished result ↓

Robotics is turning into the physical agent for LLMs. For the last few years, embodied AI has mostly been about getting robots to learn moves on their own. Train with RL over and over. Collect teleop data to train VLAs. Chase general-purpose humanoids with dexterous hands. What you get: pricey data, a zoo of incompatible hardware, and slow progress. There's another path that's starting to actually work: don't make the robot think. Let the LLM do the thinking. The model looks at the camera feed, figures out the task, breaks it into steps, then uses tool calls to hit the arm's "move", "grip" and "release". Picture a really smart kid with a game controller, staring at a screen, driving a robot arm. Someone just had GPT-6 Astra run two arms through vessel suturing in a sim built in Godot, a game engine. It's just a sim, nowhere near real surgery. But it shows something: LLMs are getting good enough at spatial reasoning and long-horizon planning to start calling the shots in the physical world. So here's how the work splits up: 🧠 Brain: LLM / VLM. Thinks every few seconds. Decides what to do. 🦴 Cerebellum and spine: motion planning, low-level control, safety. Reacts in milliseconds. Figures out how to move without crashing into stuff. My little propeller balancing toy has to tweak its PWM every 10 ms or the stick just falls over. One LLM tool call takes a few seconds. Doesn't matter how smart the brain is, it can't do the cerebellum's job. But the "what to do" part? That's going to the models, more and more. So what does this mean for robotics companies? An agent is basically a reseller. Robots are going to be the LLMs' resellers in the physical world. Better models make robots more useful, sure. But more of the value keeps flowing upstream to OpenAI, Anthropic and Google. The robotics companies that make it will look like the resellers that make it. Two kinds: • The ones that nail the "cerebellum": hardware, control, safety. Stuff the model can't do for you. • The ones that go really deep on one setting: the workflows, data and customers of a specific factory, lab or warehouse. If you're just a middle layer, upstream will squeeze you sooner or later. LLMs won't replace robotics. Robotics will become their hands and feet. Inspired by @lidangzzz's ideas and @maoconsult511's experiment. Thanks, both.

here's detail write up of my pi-based always on agentic software factory centered around effect, alchemy, and celld my current favorite piece is the "social network" we use for agent to agent comms 😍

THE COMPLETE AI REVERSE-ENGINEERING TOOLKIT: 150+ FREE RESOURCES Agents, free courses, native binaries, .NET, iOS, Electron, browsers, firmware, WASM and protocols, and most builders have no idea it's all free 01 - START WITH REA Installation and agent setup github.com/morluto/rea/blob/… Your first REA investigation rea.tools/first-investigatio… REA guides rea.tools/guides/ Guided MCP prompts github.com/morluto/rea/blob/… MCP runtime contracts github.com/morluto/rea/blob/… Also useful: Evidence Workflows · Native Investigation Guide · JavaScript Application Graph · Electron Observation Guide Install: npx rea-agents@latest setup 02 - REAL REA INVESTIGATIONS Notes Export - button → IPC → CSV rea.tools/first-investigatio… Notion Clipboard - page API → preload → main process rea.tools/showcase/notion/ DX-Ball - Windows binary → verified C function rea.tools/showcase/dx-ball/ Aegis - APK → TOTP implementation rea.tools/showcase/aegis/ Also useful: CTF Flag Checker · REA Gems · Chrome Dinosaur investigation · Notes Evidence Record 03 - AI REVERSE-ENGINEERING AGENTS IDA Pro MCP github.com/mrexodia/ida-pro-… GhidrAssistMCP github.com/symgraph/GhidrAss… GhidraMCP github.com/LaurieWired/Ghidr… Official radare2 MCP github.com/radareorg/radare2… Also useful: Revenant · Awesome LLM Reverse Engineering · AgentRE-Bench · SRE-Bench · Reverse Engineering Agent Skill 04 - NATIVE BINARIES Ghidra github.com/NationalSecurityA… radare2 github.com/radareorg/radare2 Rizin github.com/rizinorg/rizin Cutter github.com/rizinorg/cutter Also useful: Keystone · GNU Binutils · GDB · LLDB · pwntools · ROPgadget · Detect It Easy · capa · YARA 05 - .NET APPLICATIONS ILSpy github.com/icsharpcode/ILSpy dnSpyEx github.com/dnSpyEx/dnSpy dnlib github.com/0xd4d/dnlib de4dot github.com/de4dot/de4dot Also useful: AsmResolver · Harmony · Mono.Cecil · NativeAOT reversing helpers 06 - iOS Frida iOS Guide frida.re/docs/ios/ OWASP iOS Testing Guide mas.owasp.org/MASTG/0x06b-Ba… DVIA-v2 github.com/prateek147/DVIA-v… libimobiledevice github.com/libimobiledevice/… Also useful: ios-deploy · class-dump · ipsw · Objection iOS 07 - ELECTRON AND JAVASCRIPT Electron ASAR github.com/electron/asar Electron Process Model electronjs.org/docs/latest/t… Source Map Explorer github.com/danvk/source-map-… AST Explorer astexplorer.net/ Babel Parser github.com/babel/babel/tree/… Also useful: Electron Security Guide · source-map · Esprima · Acorn · JS Beautifier 08 - BROWSERS AND WEB APPS Chrome DevTools Protocol chromedevtools.github.io/dev… Chrome DevTools developer.chrome.com/docs/de… Puppeteer github.com/puppeteer/puppete… Playwright github.com/microsoft/playwri… Also useful: OWASP ZAP · HTTP Toolkit · WebSocket King · Firefox DevTools · HAR Specification 09 - FIRMWARE AND DEVICES Binwalk github.com/ReFirmLabs/binwal… EMBA github.com/e-m-b-a/emba FACT Core github.com/fkie-cad/FACT_cor… FirmAE github.com/pr0v3rbs/FirmAE Also useful: sasquatch · ubi_reader · Jefferson · Firmware Mod Kit · Firmware Analysis Toolkit · Revenant 10 - WEBASSEMBLY WABT github.com/WebAssembly/wabt Binaryen github.com/WebAssembly/binar… wasm-tools github.com/bytecodealliance/… Also useful: Wasmtime · Wasmer · wasm-decompile · wasm2c 11 - NETWORK PROTOCOLS Wireshark gitlab.com/wireshark/wiresha… Scapy github.com/secdev/scapy Zeek github.com/zeek/zeek Boofuzz github.com/jtpereyda/boofuzz Also useful: tcpdump · PcapPlusPlus · Construct · Netzob · Wireshark Display Filters 12 - FREE COURSES AND PRACTICE OpenSecurityTraining2 x86-64 Assembly p.ost2.fyi/courses/course-v1… pwn.()college Reverse Engineering pwn.college/cse365-s2026/mod… pwn.()college Reversing Hell pwn.college/reversing-hell/ Malware Unicorn RE101 malwareunicorn.org/workshops… Also useful: RPISEC Modern Binary Exploitation · UMass Reverse Engineering · OpenSecurityTraining Intro x86 · crackmes.()one · Microcorruption · Flare-On · Malware Traffic Analysis · OWASP MASTG · OverTheWire · PicoCTF THE FASTEST PATH Install REA → investigate one feature → collect Evidence → trace the complete function → write a clean-room specification → build an independent implementation → compare it against the authorized original → keep every failure and unknown visible Start small: Notes → Notion → CTF binary → Aegis APK → DX-Ball → firmware, protocols and real applications Save this. Pick one target. Reverse engineer one feature.

JPMorgan revealed repo they use to train thier Quants to build trading & research systems JPMorgan's Quants should learn Python for this - you just send it to any LLM or AI agent get your own trading Quant: 1. open LLM or AI agent and send it: github.com/jpmorganchase/pyt… 2. say: "set this up and redo every notebook on NVDA with real data" 3. it prices an options straddle for your stock, by formula and Monte Carlo 4. it scores company's bankruptcy risk with Altman Z'' and gives an implied credit rating 5. it vuilds the 3D vol surface and yield curve charts 6. then say: "turn all of this into one live dashboard for my stock" that's it. then read below how to run your own AI hedge fund:

AI Agent Engineering — Ultimate Roadmap (SAVE NOW)! ├── 01 Foundations & Role │ ├── What an AI Agent Actually Is (vs Chatbot/Workflow) │ ├── Agent vs LLM vs Automation │ ├── Core Components: Model, Tools, Instructions, Memory │ ├── Spectrum of Autonomy & When Not to Use Agents │ └── Stakeholders, Constraints & Cost/Latency Drivers ├── 02 Agentic Thinking │ ├── Start Simple → Add Complexity Only When Needed │ ├── Tradeoff Analysis (Latency, Cost, Reliability, Control) │ ├── Workflows vs Agents (predefined paths vs dynamic loops) │ ├── Failure Modes, Hallucinations & Recovery │ └── Context Engineering (high-signal tokens, attention budget) ├── 03 Core Patterns & Loops │ ├── ReAct (Reason + Act + Observation) — foundational loop │ ├── Chain-of-Thought, Tree-of-Thoughts, Plan-and-Execute │ ├── Reflexion & Self-Correction │ ├── Prompt Chaining, Routing, Parallelization, Orchestrator-Worker │ └── Evaluator-Optimizer & Stopping Conditions ├── 04 Tools, Actions & Protocols │ ├── Function/Tool Calling Fundamentals │ ├── Designing High-Quality Tools (clear names, schemas, error handling, examples) │ ├── Model Context Protocol — open standard for tools & data │ ├── Tool Inventory Design & Selection │ └── Action Types (read, write, code execution, browser, computer use) ├── 05 Memory & Knowledge │ ├── Short-term vs Long-term / Episodic / Semantic Memory │ ├── Context Window Management & Compaction │ ├── RAG for Agents (retrieval as a tool) │ ├── State & Checkpoints (durable execution) │ └── Memory Patterns That Survive Production ├── 06 Frameworks & Orchestration │ ├── Raw LLM APIs First (understand the loop) │ ├── LangGraph — stateful graphs, checkpoints, production control │ ├── CrewAI — role-based crews for rapid multi-agent prototypes │ ├── OpenAI Agents SDK, Claude Agent SDK, Microsoft Agent Framework │ └── When to Adopt a Framework vs Stay Minimal ├── 07 Multi-Agent Systems │ ├── Single Agent vs Multi-Agent Trade-offs │ ├── Orchestrator-Worker/Manager Patterns │ ├── Handoffs, Agents-as-Tools & Decentralized Patterns │ ├── Communication, Roles & Specialization │ └── Agent-to-Agent Protocols ├── 08 Evaluation, Observability & Reliability │ ├── Building Eval Sets Before Code │ ├── Tracing, Logging & Debugging Agent Trajectories │ ├── Metrics: Task Success, Steps, Cost, Latency, Robustness │ ├── Guardrails, Safety & Least Privilege │ └── Human-in-the-Loop & Approval Gates ├── 09 Production & Evolution │ ├── Deployment (Cloud Run, containers, sandboxes) │ ├── Cost Control, Token Optimization & Model Routing │ ├── Security (prompt injection, tool abuse, secrets) │ ├── Monitoring, Alerts & Continuous Improvement │ └── Harness Engineering & Long-Running Agents ├── 10 Practice & Path │ ├── Build From Scratch (TinyAgent / raw loop) │ ├── Key Papers: ReAct, Toolformer, Generative Agents, Reflexion Learn to design agents that survive real tasks, teams, cost & change.

Startups and inference vendors now face product trade-offs. With looped and depth-grown designs showing earlier prompt learning, teams will prioritise prompt-engineering and runtime support for reused-layer models instead of denser scale-ups. fathom.news/prompts-earlier-…

Alright I finally have more to share on my personal project! Resin is a runtime for building fast LLM inference engines. The idea is to make all the generic parts of inference reusable, and leave only the model-specific forward pass + kernels to be written for each architecture / hardware target. To build an engine: 1. Import Resin's core. 2. Have an agent write a forward pass for the model you’re interested in, for your specific hardware (GPU or TPU or AMD), any kernels you want. Then, boom, you have a standalone inference engine. — I've been hacking over the past month (early post: xitter.cf/ekzhang1/status/208950…), and recently this week I got a lot of features + parallelisms working, inspired by DeepInfer. For DeepSeek-V4.1-Flash, it's nearly as fast as DeepInfer (within 5-10%), while being self-contained and supporting other models, plus metrics + HTTP server + prefix cache. Yesterday I wrote a skill for authoring models and put Codex to work on it overnight. The agent built a GLM-5.3-Flash engine with MTP, reaching up to 60,000 input tok/s and 16,000 output tok/s on B200 (EP4). So far inference "vibe coding" has not been very reliable or successful. I think it's because people start from scratch each time and reinvent lots of tricky things on the scheduler and server layers. But with a shared core, we can automate lots of inference work. The tricky bit is writing a fast forward pass. But Resin turns that into a standalone engine by just importing a library, and it becomes a verifiable goal for the AI. Code: github.com/ekzhang/resin