AI Engineer
Every summary, chronological. Filter by category, tag, or source from the rail.
Governing AI Skills: Scaling Agentic Workflows
AI-native organizations must treat 'skills' as first-class, governed assets—similar to microservices—to avoid technical debt, ensure deterministic outcomes, and maintain security at scale.
AI EngineerFormal Verification for AI-Generated Code with Lean4
As AI agents generate code at scale, traditional testing and human review fail to guarantee correctness. Formal verification using Lean4 allows developers to define specifications that machines prove mathematically, ensuring code is correct for every possible input.
Diffusing AI into Real-World Services Businesses
AI adoption in services requires moving beyond demos to 'co-designing' technology with operators. By acquiring businesses and embedding AI directly into their workflows, builders can create real-world evals, close the feedback loop, and earn the right to move from co-pilots to autonomous co-workers.
Scaling AI Agents Safely: A Roadmap for Engineering Teams
Adopt AI agents by prioritizing verification over prompting, treating skeptic feedback as a safety roadmap, and maintaining human-centric communication standards to avoid 'slop'.
From AI-Assisted to AI-Native: Frontier Development Habits
Productivity gains from AI aren't about the tools, but about shifting from 'vibe coding' (babysitting) to 'frontier development' (feeding agents), which requires intentional changes to team habits and codebase hygiene.
Avoiding Disaster When Vibe-Coding Billing Engines
Use AI agents to accelerate setup in test environments, but maintain a human-in-the-loop for production billing logic to avoid runaway spend and configuration errors.
Architecting Production-Grade LLM Gateways
LLM gateways require a shift from standard API engineering: prioritize per-request fallbacks over circuit breakers, track latency per-route rather than globally, and treat guardrails as unreliable services that require explicit fail-open/closed policies.
Scaling AI Evals via Cross-Functional Ownership
DoorDash’s GenAI platform team scaled evaluations by moving from an engineering-only task to a cross-functional workflow, using stable APIs and 'vibe-coded' UIs to empower non-engineers to own quality.
Building uReview: Scaling AI Code Review at Uber
Uber built uReview, a multi-agent code review engine, to solve the bottleneck of increasing PR review times. By focusing on observability, team-specific customizations, and feedback-driven tuning, they achieved a 60% cost reduction and a 67% addressal rate for AI-generated comments.
Building Figma's MCP Server: Lessons in AI Integration
Figma built its first MCP server by prioritizing local-first architecture, iterative evaluation with LLM judges, and mapping design components to production code via Code Connect to ensure high-fidelity, maintainable output.
Building Context Engines for AI Agents
AI agents fail at complex tasks because they lack organizational context, leading to 'satisfaction of search' errors. A context engine provides intent, conventions, and historical data, reducing token waste and preventing compounding logic errors.
AI EngineerCan LLMs Write Fast Multi-GPU Kernels?
While LLMs excel at single-GPU code, they struggle with multi-GPU kernel optimization because they lack a deep, reasoning-based understanding of interconnect topologies, data partitioning, and the complex trade-offs between copy engines and tensor memory acceleration.
How Anthropic Builds: Lessons from Labs
Mike Krieger explains how Anthropic Labs uses 'unreasonable' delegation to AI, two-week pivot cycles, and artifact-based communication to ship products faster, emphasizing that the bottleneck to progress is human comprehension, not model capability.
The Agentic Commerce Stack: Building Reliable AI Shopping
Agentic commerce is shifting from brittle browser-automation to standardized protocols like ACP and UCP. To build reliable shopping agents, developers must move away from DOM-scraping toward structured product feeds, standardized tool access (MCP), and rigorous behavioral evals to prevent production failures.
Optimizing Agentic Inference: KV Cache Routing and P/D Disaggregation
Agentic workloads require moving beyond steady-state benchmarks. By implementing KV cache-aware routing and decoupling prefill from decode compute, teams can achieve 4x faster time-to-first-token and significantly smoother inter-token latency.
The Rise of Agent Advocacy: Adapting DevRel for AI
Developer Relations is not dead, but its audience has shifted. To remain relevant, companies must optimize for 'Agent-Led' discovery and usage by treating AI agents as first-class users alongside human developers.
AI EngineerScaling Go-To-Market Teams with Agentic Workflows
Justin Joyce of Cloudflare explains how to scale GTM operations by replacing manual spreadsheet analysis with a three-pillar agentic framework: skill-based data querying, automated insight delivery, and a self-service agentic workspace.
Treating Go-To-Market as an AI Engineering Problem
Go-to-market (GTM) is fundamentally a data problem. By building a live model of your market and empowering teams with custom agents and programmatic APIs, you can scale GTM operations with a lean, highly productive team.
Optimizing Documentation for AI Agents
To drive AI-agent adoption of your library, stop relying on web search. Instead, ship bundled markdown files directly within your package and provide hand-curated llms.txt files to ensure agents have accurate, token-efficient context.
Scaling AI Agents: Lessons from Snowflake's GTM Assistant
Successfully deploying AI agents at scale requires prioritizing quality over coverage, aggressive change management, and a willingness to rearchitect as user expectations evolve.
Building Blocks of Go-to-Market Orchestration
Go-to-market orchestration is about moving from manual, siloed campaigns to describing intent and having agents execute across channels. The key is building a unified data substrate and solving narrow, vertical use cases before scaling horizontally.
Engineering a Unified GTM System at Notion
Notion unified its fragmented GTM operations by treating them as a distributed systems problem, building a shared context layer where humans and AI agents operate on the same substrate to drive proactive, signal-based workflows.
GTM Engineering: Building a Technical Foundation for Growth
GTM engineering treats go-to-market operations as a software engineering problem, focusing on data resolution, complex orchestration, agentic decision-making, and execution to build a 'perfect virtual copy' of the market.
Reverse-Engineering the AI Buyer: A Go-to-Market Playbook
Stop building sales teams before you build the machine. Automate your funnel, prioritize self-serve motions to find product-market fit, and reserve human-led sales for high-value enterprise deals.
Designing AI Environments for Collective Intelligence
Moving from rigid agent workflows to open, incentive-driven environments enables AI to solve complex scientific problems and optimize GPU kernels through collective, iterative collaboration.
AI EngineerBuilding Agentic Platforms: The Potter's Workshop Approach
Safia Abdalla argues that AI agent platforms should abstract infrastructure complexity, provide consistent multi-harness support, and act as 'potter's workshops'—structured, observable systems that empower humans to ship software rather than just automating code production.
AI EngineerBuilding Reliable AI Evaluation for High-Stakes Domains
Static rubrics fail to catch critical AI errors because they lack context. Instead, build a continuous loop: discover failure modes from real outputs, capture expert judgment, and calibrate each evaluation using case-specific context.
Building an Agent Kernel: Why Frameworks Fall Short
Instead of using complex agent frameworks, build a simple 'kernel' that treats agents as isolated processes. Use content-addressed prompts, event-driven architecture, and strict type boundaries to ensure reliability and auditability.
Scaling AI Engineering: From Solo Prompts to Systemic Automation
AI-powered development scales not through individual prompting, but by building reusable harnesses and system-level context that reduce human intervention and standardize engineering practices across teams.
Model Routing: Moving Beyond Leaderboard Benchmarks
Stop relying on a single 'best' model. Use a task-aware router to dynamically select models based on your specific cost, latency, and quality preferences, achieving comparable results at a fraction of the cost.
Showing 30 of 330