Learn
Archive of engineering deep-dives — start anywhere.
- EP231: AI Terms You Need to Know What else should be on the list?
- Data Movement Strategies In System Design To manage this movement of data, you need to make decisions about when and how information should travel within a system and outside it.
- How Uber Built A Gateway For AI Agents To Access Tools In this article, we’ll look at how Uber built this gateway in detail.
- Help set Go's priorities for next year Share your experience with Go in the 2026 Go Developer Survey, open through November 3.
- How Apple Fits an LLM on Your iPhone How is Apple able to fit such a model on an iPhone without any adverse impact on the device?
- Our Response To The eMudhra Key Disclosure Incident How the Go team responded to the eMudhra certificate compromise with our first-ever URGENT track security release.
- A Deep Dive into Salesforce’s Agent Tech Stack Salesforce moved to a new design, a multi-layer system that combines deterministic code with reasoning models for maximum reliability.
- Last chance to get every live course in one membership We’ll stop selling ByteByteGo Live annual memberships on October 28 at 2 PM PT. After that, courses will be sold individually.
- EP230: RAG vs Agentic RAG Here's how RAG and agentic RAG typically work.
- Feng Shui for Robots: The Fly MCP Server In Databricks’ State of AI Agents 2026 report, there’s a chart from Neon’s telemetry that’s somehow both mind-blowing and unsurprising. In October 2023, AI agents created 0.1% of the databases on Neon. By October...
- SBD: We Have a Filesystem at Home I have unkind things to say about people who make their own pasta. Here, I’ll only use them as an example of how not to think when you’re building infrastructure. It’s unfairly easy to believe that the harder you w...
- Why Distributed Systems Prefer Independence over Coordination In this article, we’ll look at why coordination is a challenge for distributed systems.
- Interactive refactoring in gopls Introducing interactive refactoring in gopls and the LSP: a new capability that brings dynamic, multi-step refactorings into your favorite editor.
- LLM Prompt Caching Versus Semantic Caching In this article, we’ll look at how LLM caching works in detail.
- Why Shopify Migrated From React Native In this article, we’ll look at how Shopify decided to move out of React Native and how they migrated to native mobile development.
- How Uber Built a Genie to Answer Questions Correctly In this article, we will understand how Genie prepares knowledge, retrieves it, and generates answers.
- EP229: 8 Chunking strategies for RAG-based agents Which chunking strategy are you running in production?
- Better HTTP/1 connection reuse Go 1.27 includes a change to the HTTP client that can make programs sending many sequential HTTP/1 requests significantly faster.
- How to Design for Failures In this article, we’ll look at the various strategies that can help developers deal with failures in their systems.
- Arch-specific SIMD in Go Go 1.27 introduces experimental arch-specific SIMD vector APIs
- The Terminator Problem: How Teaching an LLM One Bad Habit Can Change Its Behavior To understand why this happens, we need to connect three ideas: how models learn, how they generalize beyond their examples, and how they exhibit different kinds of behavior.
- How the Math Used in 19th-Century Heat Physics Helps LLMs Understand Sentences In this article, we are going to understand how this connection works and why a model needs help understanding the order of the words even when the words already arrive in an ordered list.
- How to Build Models Without Language, with Logical Intelligence Something unusual happened in a public Sudoku experiment early this year.
- How Software Boundaries Are The Most Important Skill for Developers In this article, we’ll learn some key strategies that can help a developer make the right boundary-related decisions for the systems they are working on.
- How Netflix Taught an LLM to Recommend Movies So That You Keep Watching In this article, we will look at how GenRec was built.
- Why LLMs Agree With You Even When You’re Wrong When LLMs sometimes agree with incorrect claims, it is mostly because their training rewards such behaviour. This reward system is built on several things at once, such as accuracy, helpfulness, politeness, and responses...
- The LLM Blindspot: Why Models Forget What’s in the Middle of Your Prompt In this article, we’ll look at why LLMs have this bias against middle information.
- Last 3 days: AI Evals, October cohort Secure your spot in AI Evals in Practice. Enrollment closes in just 3 days! If you’ve been thinking about joining, now’s the time.
- EP228: How SSH Works Secure shell is a method to access a remote machine securely over an unsecured network. It starts with a TCP connection from the SSH client to the remote machine (SSH server).
- Platform-independent SIMD in Go Go 1.27 adds an experimental platform-agnostic SIMD API
- Why State is the Hardest Thing in Software Design In this article, we will look at why state is the hardest thing in software development and the multiple strategies that developers can use to manage it.
- AI Agents Can Think. Now They Can Pay. I attended a MPP event at Stripe HQ, where I spoke with Emily Sands and Matt Schulman from Stripe, along with Brendan Ryan from Tempo.
- How DoorDash Built a Toolbox for AI Agents In this article, we will look at how the DoorDash engineering team built this gateway and the decisions they made.
- Why Do LLMs Lie? In this article, we will look at why this problem of hallucinations happens with LLMs and the techniques that can help make LLMs more dependable for answering.
- EP227: Top 9 Places to Use Jev Jev is TypeSafe AI’s first System One Model. It is 100x faster and cheaper than frontier LLMs.
- LAST CALL FOR ENROLLMENT: Rebuild YouTube with AI Rebuild YouTube with AI, taught by a former YouTube engineer, kicks off on Saturday, September 26. Enrollment closes in 24 hours.
- Size-Specialized Memory Allocation Go 1.27 improves performance of small allocations using size-specialized allocation functions.
- The Life of Data: From Creation to Deletion In this article, we are going to look at the entire data lifecycle from creation to deletion and the decisions that need to be taken at each step.
- How to Customize a Model to Learn New Tricks In this article, we are going to look at the various strategies to customize and fine-tune a model.
- How OpenAI Built GPT-Live To understand how it all works end to end, we met with engineers on the GPT Voice team, Zahan Malkani and Justin Uberti (who created WebRTC).
- How to Run a Big Model on Cheap Hardware? A large AI model can run on modest hardware only by reducing the memory it occupies, reducing the calculations it performs, or moving some work to slower hardware.
- EP226: API Concepts Every Software Engineer Should Know Sending a request and reading JSON is one thing. Designing an API that other people can rely on is something where things get complicated.
- Migrations at Scale: Changing the Application Engine at 30,000 Feet In this article, we will look at how migrations work at scale and the key strategies that can help make it as efficient as possible.
- Goroutine Leak Profiles Go 1.27 includes new goroutine leak profiles.
- How LLMs Can Find a Needle in a Haystack In this article, we are going to look at how LLMs can find a needle in a haystack.
- Do LLMs Have the Memory of a Goldfish? In this article, we will learn how LLMs handle memory so that they are useful to end users in performing complex tasks that require conversation and holding context.
- LAST CALL FOR ENROLLMENT: Build with Claude Code We’re relaunching Build with Claude Code, a 2-day intensive cohort-based course taught by John Kim, who has trained hundreds of engineers at Meta to use Claude Code in real production workflows.
- LLMs as a Judge: How to Know if Your LLM is Healthy In this article, we are going to look at the process of LLM evaluation in detail.
- EP225: Why Does Git Revert Cause Conflicts? git revert looks straightforward until it throws a conflict
- Learn Claude Code, evals, AI systems, and more: ByteByteGo Live is here Most online courses never get finished (~4% completion). Live cohorts get ~40%, roughly 10x higher. Live courses are the only courses people actually finish. So we’re launching ByteByteGo Live.
- A Guide to Application Networking Basics In this article, we will look at the various aspects of networking in detail.
- How Smart Model Routing Can Cut LLM Costs by 10X Cost reduction isn’t a given. It also depends on the types of requests the application receives, the price difference between models, and how well the routing system performs. In this article, we are going to look at v...
- Built for Reliability: How American Express Processes Payments at Scale In this article, we will try to understand how the transaction runs through such a cell-based architecture and how the payments are processed even when some services are failing.
- How to Deal With Errors and Failures in LLM-Powered Applications Apart from normal processing, the application also sends data to a large language model (LLM). It then uses the model’s response to carry out a task.
- EP224: MCP vs RAG vs AI Agents An AI agent is kind of an AI system where the agent performs the task autonomously and takes the decisions.
- How Databases Keep Their Sanity with Concurrency Control So how do we handle such bugs? This is what we are going to try to answer in this article.
- Your Agent Speaks MCP. Give It a Computer. Sprites are disposable cloud computers. They appear instantly, always include durable filesystems, and cost practically nothing when idle. They’re the best and safest place on the Internet to run agents and we want you...
- Generic Methods Go 1.27 adds generic methods—a highly desired language feature.
- Why Your RAG System Is Only as Good as Its Translator Model In this article, we’re going to look at how this embedding model works in an RAG setup and what makes it such a critical part of the system.
- How to Shrink a Language Model Without Making it Too Dumb Models have grown roughly 100-fold in a few years, while consumer graphics memory has roughly doubled. It’s not just a matter of tightening things up to make them fit.
- What Happens Inside an AI Chatbot Between Enter and the First Word? In this article, we are going to look at this entire journey in detail.
- Background Work: From Cron Jobs to Distributed Systems In this article, we will look at various such strategies to perform background work in detail.
- Go 1.27 is released Go 1.27 adds generic methods, encoding/json/v2 package, uuid package, faster memory allocation, goroutine leak profiles, and more.
- How to Make LLMs 3X Faster In this article, we will look at how speculative decoding works.
- How to Steal an AI Model’s Private Thoughts In August 2026, a team at MATS Research, the ELLIS Institute Tübingen, and the Max Planck Institute for Intelligent Systems wanted to test whether the encrypted reasoning blocks that Anthropic, OpenAI, and Google hand b...
- Why Code Verification Matters More Than Ever in the Age of AI In this article, we will look at how code verification works, why the rise of AI-generated code puts more pressure on it, along with the extremely useful insights from Andrea on what the future may look like.
- EP223: Ollama vs vLLM vs SGLang To use open-weight models on your machine, you have three main options: Ollama, vLLM, and SGLang. But each engine handles requests differently.
- Schema Evolution: Changing the Contract Without Breaking What Runs In this article, we will look at schema evolution and strategies for the same.
- GraphRAG: How AI Answers Questions Hidden Across Many Documents GraphRAG was designed to handle the second kind of questions, and we are going to learn more about it in this article.
- Introducing the pkg.go.dev API Introducing the new programmatic API for pkg.go.dev, allowing developers to fetch package and module data directly.
- The New American AI Model Designed to be Customized In this article, we will work through the various choices Thinking Machines made while building Inkling.
- Waymo vs Tesla: Two Ways to Build Self-Driving Cars In this article, we will take a look at both approaches.
- EP222: What is Google’s TPU? A TPU (Tensor Processing Unit) is Google’s custom AI chip, designed from scratch for the giant matrix multiplications that modern models live on. GPUs were built for graphics first.
- A Detailed Guide to API Composition Techniques In this article, we are going to dive deep into the area of the API composition problem and the patterns associated with it.
- GitHub vs Vercel vs Replit: What Dev Platforms Do When AI Code Is Cheap AI models have solved the writing code part of software development to a great extent.
- How Cloudflare Is Making AI Pay for Content In this article, we will go through Cloudflare’s solution in the following five steps.
- How to Fight Clickbait: Meta, LinkedIn & YouTube Case Studies What does it take for a social media platform to stop rewarding clickbait content?
- The Read Path versus the Write Path: Strategies and Techniques In this article, we will look at read path and write path operations and techniques in detail.
- //go:fix inline is an API migration tool Go’s source-level inliner is not about speed — it is a safe way to rewrite call sites when you deprecate an API.
- A cloud that is also an agent workplace Platforms that host apps and agent sandboxes share one constraint — isolation must be a product feature, not a blog promise.
- Agent brains vs hands — separate the loop from the shell Keep the agent process durable; run risky commands in a disposable sandbox you can checkpoint and burn.
- Disposable sandboxes speaking MCP MCP is just a tool protocol — the interesting part is where those tools are allowed to run.
- How Big Models Teach Small Models to Be Smart In this article, we will walk through the idea from the ground up.
- LLM security is a threat surface map, not a prompt tip Treat model-backed products like networked systems — inventory trust boundaries before you ship tools.
- Type construction and cycle detection (Go 1.26) Recursive types are easy to write and hard to validate — Go 1.26 tightens construction and cycle checks.
- Why LLM memory gets expensive (and what to cut first) Context windows are not free RAM — every token you keep multiplies cost, latency, and failure modes.
- pkg.go.dev now has a real API — stop scraping docs The pkgsite HTTP API is GET-only and precision-first — ambiguous module paths fail instead of guessing.
- //go:fix inline and the source-level inliner How Go 1.26's source-level inliner works, and how it can help you with self-service API migrations.
- Building Agents that Don't Break Themselves Building agents is fun. Rebuilding agents that break themselves… less so. A lot of Fly people are building agents with less of a penchant for self-destruction by teaching their agents to do anything risky in a Sprite....
- Hiring: Part Time Instructor, Write Production Grade Code with AI We’re hiring a part-time instructor for “𝐖𝐫𝐢𝐭𝐞 𝐏𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐆𝐫𝐚𝐝𝐞 𝐂𝐨𝐝𝐞 𝐰𝐢𝐭𝐡 𝐀𝐈”.
- LLM Security Basics: The Full Threat Model In this article, we try to build a map of the full attack surface that threatens an LLM’s security.
- Turn And Face The Strange We’re Fly.io, a public cloud platform that is both our favorite way to put an app on the Internet and our favorite way to safely let a frontier agent coding harness cook. This is a post about our company, the future, a...
- Type Construction and Cycle Detection Go 1.26 simplifies type construction and enhances cycle detection for certain kinds of recursive types.
- Unfortunately, Sprites Now Speak MCP Sprites are disposable cloud computers. They appear instantly, always include durable filesystems, and cost practically nothing when idle. They’re the best and safest place on the Internet to run agents and we want you...
- Why An LLM’s Memory Gets Expensive and How to Fix It In this article, we will learn how LLMs use memory, how it gets expensive, and how to fix it.
- Cache stampedes without the folklore Why a cold key can melt a backend — and the boring patterns that keep thundering herds from forming.
- Escape analysis without the folklore What the compiler actually decides when a value lives on the stack vs the heap — and how to read the evidence.
- How schedulers wake sleeping work A practical look at runqueues, parking, and why latency spikes hide in "idle" systems.
- Token budgets with a four-character rule of thumb Why packing context often divides length by four — what that approximation buys you, and where it quietly lies.
- Ranking agent memories without a neural scorer How a small composite score — kind weights, stored relevance, keyword overlap, capped access — picks what fits a task budget.
- Mining file paths from free-form text How a small regex loop turns prose into path-like strings — with dedupe, length gates, and a hard cap of ten.