Chamber 🏰 of Tech Secrets #56: Signal in the Noise

2026 has been an interesting year. I started the year with plans to write on this blog much more often, and my array of topics to write about is overflowing.

At the same time, I feel like I have been working a 10,000 piece jigsaw puzzle blindfolded. I know I am working a puzzle. My fingers can feel some meaningful and useful pieces. I just can’t figure out how to assemble them to create the larger whole. I am not even quite sure what it is I am trying to build. I don’t feel like I have the answers. Thus I have not felt qualified to write, even while these ideas consume many of my waking thoughts.

This is of course due to AI, particularly in the realm of architecture and software engineering (but also beyond). The current climate has me thinking back to Karpathy’s X post almost daily.

Add to that routines, loops, design, and all sorts of other new features. There is so much to learn, and my own limiters are indeed a skill issue despite my best efforts to keep up.

We know these models are powerful and capable when steered well; when context is managed with near-surgical precision. How to achieve that precision is that art of AI Engineering which seems so available, yet vanishes so quickly when you attempt to grasp it. Perhaps you feel the same?

I am personally living in the tension of feeling like I need to stop all forward functional progress for a while to focus on harnessing this “powerful alien tool”. Yet there are things I simply need to get done. And thus I fall further behind.

Add to this the steady drum beat of background noise. One week, Claude Code with Opus 4.6 is “AGI” and there is nothing better. Now Opus 4.7 is out! And… it’s terrible. GPT 5.5 with Codex is way better! Anthropic just released 76 new features in 4 hours and every one of them change everything! If you have been reading "tech bro X, you know the drill.

This week, I attended Code with Claude Day in San Francisco, which was Anthropic’s first developer conference (to my understanding). I think it provided some signal in this noisy world, so I thought it time to share a few takeaways and personal thoughts.

• 3 Principles — Design for the next model, build quality evals, and treat new model upgrades as opportunity: These were 3 principles shared in the opening keynote. Designing for the next model has been an Anthropic talking point for a while, but I think they believe it. Believe in the next model. To harness its opportunity, you need high quality evals — the unit tests of the AI era — to let you quickly take advantage of new opportunities while preserving the efficacy of your current agents. If you aren’t doing evals yet, you are behind. I am behind.

• Worktrees have won the day: Across the sessions, it was clear that Git Worktrees, also supported natively by Claude, have won the day. Everyone is using them to parallelize work. If you aren’t there yet, it seems like it is time to make the shift.

• Context Switching is the new normal: Several presenters mentioned that they often had 25-30 agents running in parallel at any given time. Long running agents are rapidly becoming the norm. Another presenter suggested that you need to begin to think of yourself as a higher level, principal engineer a level removed from changing the code base. Managing context while switching context. Orchestrating outcomes.

• Loops and Routines: Everyone at Anthropic is using them. Loops for scheduled tasks and routines to drive the work. You should probably use them. I should probably use them.

• “You should be running your agents overnight”: Direct quote. No exposition needed.

• Learn hooks: Of the currently available abstractions, hooks are the most powerful for managing your context window because they enable you to take surgical actions when-and-only-when you need to. Other abstractions like skills, MCPs, and sub-agents are useful but don’t completely scale.

• “The new default is having Claude prompt Claude Code”: This was a closing statement made by Boris Cherny, creator of Claude Code. A “Boris Bomb”, if you will. I like this sort of ambitious statement to challenge us to think differently. What we are really talking about is building a system that does engineering. More on that later.

My favorite session was from Netflix. It was all about their process for building out the AI software engineering capability in their organization and how to help everyone get better. Here are a few insights…

• At Netflix, the top 1% use more AI than the bottom 78% combined. We have observed similar.

• Netflix has a data-driven approach to figuring out how is using AI well, and they permit those people to spend 30% of their time helping others grow. For “Maturity Signals”, they look at DX Core metrics, OTEL data from Claude Code, MCP plugin/skill marketplace metrics, eval metrics. They don’t measure percent of code created by AI. They also capture session traces and use these to understand engineering behaviors in hopes of helping everyone improve.

• They explored using the status line to try and communicate effectiveness-of-use to engineers. The results were not great so they have moved on for now, but hope to come back in the future. I think this is an interesting opportunity to convey data-driven insights to software engineers while they actively use the tools since it is right in their face and hard to miss.

• More evals: if you aren’t there for software engineering outcomes yet, you are behind. I am behind.

• They are sharing the data they collect across the entire software engineering population with their top AI software engineers to help the group think about how to best force multiply.

• They admitted to struggling to manage skills marketplaces, with a reported 135 skills related to managing Jira issues and a lack of clarity about which are mature and which are slop. The encouragement was to get ahead of this and develop a process for managing skill, MCP, connector / plugin marketplaces.

• Finally, they advocated for investing in composable primitives. Sandboxes, runtimes. and other components should be modular instead of vertical solutions to enable pivots and changes as the AI engineering space evolves.

• Primitives vs Solutions: I think Anthropic (and others) are in the business of providing primitives, much like AWS or Google Cloud. Every organization, every developer, is going to have to figure out how to piece together the primitives to craft a workflow — a solution — that they can manage. That management includes the technical management but also the context switching aspects. You have to be able to operate the system you build efficiently and effectively without burning out. Like we discussed with Netflix’s use case, I think primitives composed into solutions, is the right mindset for enterprises or organizations with larger teams.

• The need to pause: I said it in the opening, but it seems you have to accept a pause in productive output for some season of time to learn, figure out a new workflow, and build your “AI software factory”. There is too much happening to become a master on the side… but mastery of these primitives feels essential to successful delivery in the future. I feel like a one week pause is the minimum starting point, but recognize that is hard to achieve when business deadlines are looming.

• Sandboxes: Aside from the conference, I have been thinking a lot about sandbox environments and how they can enable safe arbitrary code execution and provide well-scope CLI tools for triaging issues without the risks of credential harvesting and production database and backup deletion. “Claude deleted my database in 9 seconds”1 should simply not be a possible outcome when you architect an effective software delivery and operations capability.

What has changed? Honestly, effective AI Engineering is still about context window management…. but the tools and techniques by which one can do so in a long-running form is improving rapidly. There are new tools and techniques to make this easier. I leave the day with some new ideas about how the best-of-the-best are harnessing these tools, and the sense that a few days of complete focus, experimentation and workflow refinement (likely building with Claude Agents SDK) would send me leaping forward. This confirmed my suspicion that I have been sitting with for a while.

I think this is the takeaway: Let Claude prompt Claude Code. Let it run a long time. Run it overnight. Let it deal with the inbounds you get. Pick your primitives. Compose a solution. Get comfortable stepping back and up. Get ready to context switch. Find the fun in it. Claude or something else, I think most of this applies.

In the next post, I aspire to write more about this, focusing on the idea of a “AI Software Factory”. What is it? Is it achievable? And what sorts of inputs are needed to create useful outputs post-processing? More to come.