A former Meta React compiler engineer and Netflix EM discusses how to build and manage multiple AI agents to automate routine work. The post highlights a SpaceXAI engineer running 10-20 agents coordinated by a "Chief of Staff" agent, framing this practical approach as more valuable than paid courses on agentic systems.

• A former SpaceX AI engineer (ex-Cursor) runs 10-20 Grok agents to automate 90% of routine work, coordinated by a "Chief of Staff" agent
• The podcast guest, an ex-Meta React compiler engineer and former Netflix EM, approaches agent tech with skepticism, detailing specific problems before showing how they're solved
• The poster frames this 50-minute conversation as more valuable than paid courses on agentic engineering

The article contrasts “smart” engineers who rely on rapid intuition with “strong” engineers who use a steady, methodical process when they hit a tough problem. It argues that identifying true system invariants and forcing yourself to sit with raw data leads to clearer thinking and more reliable solutions.

• "Smart" engineers rely on fast intuition and fall apart when it fails, flailing through fixes and defending wrong turns as "close enough"
• "Strong" engineers use a repeatable process instead: list the invariants you trust unconditionally, then test weaker assumptions one by one until you find the false one
• Grinding through raw data methodically feels frustrating but catches issues that intuition alone would miss, especially outside familiar patterns
• Training yourself to think clearly regardless of speed—not raw talent—is what lets engineers handle unfamiliar problems without collapsing into panic

The tweet tells engineers to forward their toughest technical challenges to Fable, implying the platform can tackle complex problems. It pitches Fable as a go-to resource for difficult engineering questions.

• Elvis Sun tells engineers to send their hardest technical problems to Fable
• He claims Fable can solve them, capped with a "thank me later"
• The tweet gives no specifics on Fable's features, pricing, or proof of results

ND Studio is looking for hardcore engineers and designers to tackle the most broken user experiences on Earth. Interested candidates can apply directly at ndstudio.gov.

• ND Studio (a .gov domain) is recruiting hardcore engineers and designers to fix "the most broken user experiences on Earth"
• They want hands-on specialists—front-end coders, Figma-based UX designers, and back-end performance architects—not generalists or strategists
• The focus is explicitly on code, prototypes, and rapid iteration rather than meetings or decks
• No deadline or specific role openings were given; applicants apply directly at ndstudio.gov

The author argues that engineers should target around 80% utilization—avoiding nonstop ticket grinding—to keep bandwidth for time-sensitive, high-impact tasks like unblocking deals or incident mitigation. By deliberately doing “nothing” during low-pressure periods and pushing back on non-prioritized work, you stay alert for the right opportunities and reduce stress-driven mistakes.

• Target ~80% utilization instead of nonstop ticket-grinding, keeping 20% of your day free to catch rare, high-impact moments (unblocking a deal, flipping the right flag to avert an incident).
• Looking "too busy" makes managers route around you; staying visibly available makes them think of you first for critical work.
• Treating every task as an emergency burns you out before real emergencies hit—slowing down (especially on-call) prevents rash, situation-worsening changes.
• Decline unprioritized glue work, backchannel favors, and shifting specs—absorbing them just masks organizational gaps and invites more unpaid work.

The team built a system that quantifies how much engineering work Devin delivers vs. what you pay, then backs that claim with up to $10 million per customer. They validated the methodology with independent data and benchmarks to prove Devin consistently delivers more output than its cost.

• Cognition is offering up to $10 million per customer as a refund/credit if Devin's engineering output doesn't exceed what the customer pays for it.
• The guarantee is backed by an "Engineering Velocity Score" tracking code changes, tests, deployments, and milestones, tied directly to invoices.
• Independent auditors get real-time read-only access to logs to verify data integrity and publish monthly benchmark comparisons against in-house teams, consultancies, and past Devin performance.
• Customers get a portal to track their own Velocity Score in real time, triggering automatic credits if performance falls 10% below the agreed threshold.

The article breaks down each stage of creating a Formula 1 track, from initial site surveys and earthworks to laying multiple asphalt layers and installing safety barriers. It covers design tweaks, drainage systems, and final homologation steps to meet FIA standards.

• Building an F1 track takes 2-4 years and can cost over $200 million for a street circuit
• FIA mandates track widths of 15-24 meters and runoff of 1.7 meters per meter of speed over 80 km/h
• Drainage systems remove up to 80% of water during heavy rain to prevent puddles
• Crash barriers now carry sensors recording up to 3,000 parameters per impact to inform future safety design

A former Azure engineer details how Microsoft's mismanagement and unrealistic plans jeopardized its relationship with OpenAI and the US government. The article outlines the internal chaos and lack of clarity that led to significant operational failures.

• Azure engineers seriously considered porting Windows features onto an Overlake accelerator card whose hardware specs made the task unrealistic.
• Azure infrastructure runs on 173 management agents with no clear understanding of why or how they're needed, creating major operational risk.
• This mismanagement damaged Microsoft's trust with OpenAI and the US government, key stakeholders reliant on Azure's stability.
• Warnings raised directly with Microsoft leadership went unanswered, reflecting a leadership disconnect tied to the company's massive market value loss.

This article covers highlights from a podcast conversation about recent advancements in AI models, particularly Google's new vision-capable LLMs. It discusses technical features like parameter efficiency and multi-modal capabilities, as well as ongoing challenges in running local models effectively.

• Google released Gemma 4 reasoning models (2B–31B params), with the E2B/E4B variants using Per-Layer Embeddings to boost on-device efficiency without growing total parameter count, and all versions handle text, images, and audio.
• Willison's hands-on testing found the smaller Gemma models worked well but the largest 31B model repeatedly errored out.
• A supply chain attack hit the Axios HTTP client via a malicious npm dependency, underscoring open-source package security risks.
• Willison argues efficient code will dominate AI deployment due to economic incentives, based on his experience running these models locally versus via Google's AI Studio API.

The article breaks down the recently leaked source code of Anthropic's Claude Code CLI. It highlights the system's architecture, design choices, and differences from OpenAI's Codex, particularly in handling context overflow and user interactions. Key features like compaction strategies and internal versus external user instructions are explored.

• Claude Code uses a four-tiered compaction strategy (proactive token monitoring, reactive fallback, and a "snip compaction" mode for headless sessions) versus Codex's simpler diff-based approach that just minimizes data sent per turn
• The system prompt uses a boundary marker to cache roughly 3,000 tokens of static instructions across users for performance gains
• Internal users get specialized instructions specifically designed to stop the model from misrepresenting test results or giving misleading status updates
• The codebase includes feature flags and build-time checks specifically to prevent sensitive information from leaking into public builds

This article discusses the impact of coding agents on the roles within Engineering, Product, and Design (EPD) teams. With coding becoming easier, the focus has shifted from creating detailed product requirement documents to rapid prototyping and review, emphasizing the need for generalists and strong system thinking. It highlights the evolving nature of roles where builders and reviewers emerge as distinct categories.

• Coding agents shift the bottleneck from writing code to reviewing it—checking architecture, user fit, and design quality.
• Generalists who span product, design, and engineering become more valuable because they cut coordination delays and can use coding agents directly to validate ideas.
• Weak product thinking now carries a higher cost: bad prototypes flood the review pipeline and waste team effort.
• System thinking becomes a core skill requirement—engineers need architecture/API fluency, PMs need real user insight, designers need interface judgment—so agents can be guided well instead of producing more review work.

This article discusses the need for new workflows in product development as traditional methods like Agile and PRDs become obsolete. It highlights the shift in how teams work, emphasizing the importance of tools that adapt to modern, nonlinear processes. The author argues for a new structure that aligns with current realities rather than outdated practices.

• Multiple industry voices (LangChain's Harrison Chase, Linear's Karri Saarinen, Anthropic's Jenny Wen) are independently declaring PRDs, issue tracking, and traditional design process dead or dying.
• Pull request sizes grew 154% in the last year (per Faros AI), showing AI is generating more code without solving whether it's the right code.
• The bottleneck has shifted from writing code (largely solved) to validating that products actually meet user needs.
• Design, prototyping, and coding roles are blurring into a nonlinear process that existing tools weren't built to support, prompting the creation of Enhance as a new structural approach.

The article explores the definition of an engineer and what engineering truly entails, especially in the context of advancing AI technology. It emphasizes that engineering is about taking the right actions in the right sequence to achieve various intentions, highlighting the importance of clarity in project goals and the art of sequencing tasks.

• An engineer is defined as someone who takes the right actions in the right sequence to achieve a set of intentions, not someone who builds physical things—making software engineers legitimately engineers.
• Engineering projects have multiple simultaneous intentions (resources, stakeholders, users), and failing to articulate them causes teams to build the wrong product or misalign with goals.
• Sequencing matters as much as choosing the right actions—order of operations determines success, and sequences nest recursively within larger sequences (illustrated via the hand-washing example).

Engineers face difficulties in transitioning from deterministic programming to probabilistic agent engineering, as they often struggle to trust the adaptive capabilities of AI agents. Traditional practices, such as strict typing and error handling, clash with the need for flexibility and context-aware interactions in agent systems. Emphasizing the importance of semantic understanding and behavior evaluation, engineers are encouraged to embrace a new approach that balances trust and oversight.

• Senior engineers' deterministic mindset (strict typing, exhaustive error handling) actively conflicts with building probabilistic AI agents that need flexibility
• Trust in the system has to shift from verifying exact outputs to evaluating whether agent behavior is semantically reasonable given context
• Overly constraining agents with rigid rules to feel "in control" undermines the adaptive reasoning that makes agents useful in the first place