AI Engineer Code Summit 2026 Day 2: Faster Inference, Smaller Models, and Code You Can Trust

Day 2 of the AI Engineer Code Summit 2026 moved from the workshop rooms to the main stage at the Hilton Union Square in San Francisco. Corey Quinn of The Duckbill Group hosted the morning keynote block. Four talks were scheduled, but Lydia Hallie of Anthropic was unable to present Rethinking Claude Code Best Practices because of technical issues in the conference area. The three talks that went ahead covered three layers of the agentic coding stack: how fast inference runs, which model makes a decision, and how much we can trust the code that agents write. These are my notes from the talks, along with what I think they mean for teams in the Philippines.

If you missed the first day, my notes on the Day 1 workshops cover the agent loop, the harness around it, and agent swarms.

What changes when inference is ten times faster

Natalie Serrino, co-founder of Gimlet Labs, opened with a question: What will you build when AI is 10x faster? Gimlet works on heterogeneous inference, which means running a single model workload across different kinds of chips instead of a fleet of identical GPUs.

The idea is easier to follow once you know that inference happens in phases. Reading the prompt and generating the answer place different demands on the hardware, so Gimlet splits each workload dynamically and sends every phase to the hardware that handles it best at that moment. Her claim was that this kind of multi-silicon inference meets a workload’s service levels with better efficiency and performance than running everything on one type of chip.

Three further points from her talk stayed with me:

She closed with a slide that asked the audience to imagine their own products with inference ten times faster than today. I found it a useful exercise. Many features we rule out today are ruled out because of latency, and that constraint may be loosened sooner than our roadmaps assume.

Cloudflare’s case for small decision models

Michelle Chen, Group Product Manager for Cloudflare’s AI Platform, gave the talk titled cloudflare is a neolab. She traced Cloudflare’s sixteen-year path from a content delivery network to a full cloud provider, starting with compute primitives such as Workers and arriving at Workers AI.

She was candid about one mistake. Cloudflare originally bet that small language models would be enough for most work at the edge, but larger models came to dominate, and Cloudflare ended up serving open-weight models such as Kimi, GLM, and DeepSeek. What brought the company back to small models was latency. As agents began to make many decisions inside a single task, the time each decision takes became important again.

Cloudflare’s answer is a family of models it calls “system one” models, borrowing the idea of fast, intuitive thinking. She described two of them. Clef is a small decision model. Clairic is designed for answers you cannot list up front, such as extracting, computing, estimating, and forecasting. According to her slide, it runs as a System One extraction model in a single pass with no output tokens, and every answer comes with a confidence score. Training its own models is the reason she described Cloudflare as a neolab, and she presented these models as the piece that completes its agent cloud.

Her benchmark compared an all-LLM approach using GLM 5.3 against a mixed system that sends suitable decisions to a system one model. The mixed system answered at a fraction of the LLM’s cost and time, running about 1.9 times faster and costing about 72 percent less. Her conclusion was that the new pattern combines large generative models with small decision systems.

All code is slop until you can verify it

Lauren Tan, a Principal Engineer at SpaceXSI who works on Grok Bot and client architecture, gave the talk titled All Code Is Slop (Except Mine). She is an eloquent speaker, and I think this was the talk most useful for engineering leaders. Her team lands around ten thousand pull requests a month while still improving quality, and she described the advantage for an organization as velocity without compromise.

Her framework starts from the observation that teams can run agents in a low-trust mode or a high-trust mode, and the goal is to reach the high-trust mode. She described the layers that build that trust, from the bottom up:

Code is memory

One idea from the talk reframed how I think about codebases. Agents treat existing code as memory, so whatever patterns live in the repository will be repeated. The directory structure is a form of context, and a clean structure tells an agent where things belong. She described quick fixes as harmful for the same reason, using a timeout workaround as her example: one shortcut becomes a pattern the agent will reproduce elsewhere. She also called comments a liability, because a comment that drifts away from the code it describes gives the agent wrong information with apparent authority.

Verification is the most important step

This is the golden age of software testing and verification.

She spent the most time on verification, and she described several levels of it:

• Runtime verification, where the agent checks behavior against a map of the product's features. She pointed to a create-verification skill on Cursor's GitHub as a starting point.
• Formal verification for the parts that must be correct, using TLA+ models and Lean proofs.
• Property-based testing for user interfaces, using a tool called Bombadil.

She ended by describing Grok Bot as the “outer loop” for her team. The coding agents do the work inside the loop, and Grok Bot manages the workflow around them. Her example was an agent thread that had fuzzed a Linux build, compared every finding against the previous release, and reported the new bugs first, ordered by severity.

What I am taking home

The three talks describe the same system from different angles. Inference is becoming faster and cheaper, small models are taking over the many routine decisions inside an agent, and the remaining constraint is our ability to trust what the agents produce. For most Philippine teams I work with, that last constraint is the one to invest in now. Faster models and smaller routers will arrive through providers, but the verification layer, the clean codebase, and the review discipline have to be built by your own team.

If you are planning to move agent-written code into production and want help designing that verification layer, our Claude Professional Services team can work through it with you. I will share notes from the rest of Day 2 in the coming days.