My Week in New York: The Future of Code Arrived Early

Last week in New York felt like a glimpse of what our industry will look like in the next 6-12 months. Two conferences—AI Engineer CODE NYC and *AI Native DevCon*—along with countless meetups happening simultaneously, painted a vivid picture of the transformation reshaping how we build software.

The talks were just the beginning. The conversations in between—with builders, skeptics, and fellow explorers—amplified everything tenfold. From that whirlwind, certain moments crystallized. Here are the talks that stuck with me, each one a window into the new “physics laws” of software being written in real-time.

Part 1: When Code Became Salt (The Philosophy Shift)

Chris Messina’s “Code as Commodity” was the perfect philosophical foundation for the week. The inventor of the hashtag compared code to salt—once so valuable that Roman soldiers were paid in it (hence “salary”), now a commodity that enables entirely new possibilities. His confession hit hard: “I’ve done more code check-ins in the last six months than in 20 years.”

When code becomes commodity, what becomes valuable? Messina’s answer: Taste, Judgment, Cultural Fluency, Orchestration, and Narration. His warning about generic AI aesthetics being “immediately recognizable and dismissible” became a recurring theme throughout the week.

Building on this foundation, Ryan Carson’s warehouse visualization gave us a mental model for this new world. Picture thousands of glowing white cubes in a dark warehouse, each containing a ghost (AI agent) reading instructions from pneumatic tubes. “Your job isn’t to be in the cube,” Carson explained, “it’s to design the tube network.” He backed this philosophy with action—migrating 40,000 lines of code to a new framework in just three days because “code is cheap, ideas are all that matter.”

This philosophical shift reached its apex with Steve Yegge and Gene Kim’s provocative declaration: “If you’re using an IDE starting January 1st, you’re a bad engineer.” Their diver metaphor crystallized the paradigm: stop giving one diver a bigger oxygen tank (bigger context window)—send a team of specialized divers instead. Yegge’s vision of what comes next was even more radical: “Current coding agents are like saws and drills—powerful but manual. The future is CNC machines—giant automated systems where engineers don’t look at code directly anymore.” We’re not just changing how we write code; we’re approaching a world where code becomes invisible to its creators.

Swyx’s opening war on “slop” set the tone for quality in this new era. His law—that the taste needed to fight slop is an order of magnitude bigger than that needed to produce it—became the rallying cry. The opposite of slop? “Kino”—cinema-quality output that requires human taste and judgment.

Part 2: Enterprise Reality Check (Scale Changes Everything)

The enterprise talks grounded the hype in operational reality. Topo Pal from Fidelity Investments delivered perhaps the week’s most surprising enterprise case study: a massive financial institution actively experimenting with AI-generated code. The real insight was Fidelity’s pragmatic approach to deployment: “Am I ready to use AI to write software that handles money? Not yet. Internal tools? 100%.” His warning about how “the amazing speed that AI coding agents produce will create back pressure on our software delivery process” revealed how even conservative enterprises are grappling with AI’s velocity. When century-old financial institutions are shipping vibe-coded internal tools to production, the revolution isn’t coming—it’s here.

Sneha Tuli from Microsoft revealed that 5% of all Microsoft PRs are already AI-reviewed, but with a crucial insight: “More context does not always mean better decisions—it can confuse AI.” The human-in-loop remains essential: “AI suggests, we decide.”

Lisa Orr from Zapier showed how AI democratizes development: their Scout agent enables support teams to ship 40% of bug fixes directly. “Support teams are closest to customer pain,” she noted, “and embedding tools is the key to usage.” This isn’t about replacing developers—it’s about empowering everyone to fix what they encounter.

McKinsey’s analysis explained why enterprises only see 5-15% productivity gains: legacy Agile processes create friction. Their solution? Move from “two-pizza teams” to *“one-pizza pods”*—smaller, more autonomous units that can actually leverage AI’s speed.

Yegor Denisov-Blanch from Stanford provided the data everyone needed: environment cleanliness strongly correlates with AI productivity gains. His cautionary tale—one company saw 14% more PRs but 2.5x rework, resulting in negative ROI—proved that adoption without adaptation is dangerous.

Dex Horthy from Human Layer delivered perhaps the week’s most important technical insight: model performance degrades significantly after the context window is 40% full. His mantra “Don’t outsource thinking” became a recurring theme—AI amplifies the thinking you’ve done or the lack thereof.

Part 3: The Vibe Revolution (New Ways of Working)

The philosophical shifts manifested in radically new working methods. Kitze’s talk distinguished between naive “vibe coding” and skillful “vibe engineering.” The difference? Deep technical context and understanding. Her insight that “managers have been vibe coding forever” drew knowing laughs, but her advocacy for voice coding as a “game changer for expressing thinking out loud” pointed to a fundamental shift in how we communicate with machines.

Dan Shipper from Every showed what 100% adoption looks like: 99% AI-written code, single developers maintaining entire production apps, new hires productive on day one. His key insight: there’s a 10x difference between 90% and 100% AI adoption. But his most radical observation was about “compounding engineering”: “In traditional engineering, each feature makes the next feature harder to build. In compounding engineering, each feature makes the next feature easier to build.” They’re not just using AI—they’re redesigning software development to accelerate with scale.

Beyang Liu from Sourcegraph captured the daily reality: “I think of my editor now more as a readitor.” You’re not editing anymore; you’re reading and reviewing. They even “shipped ads in the terminal” to make AI agents accessible cost-wise—a pragmatic solution to a real problem.

Part 4: The Quality Paradox (Redefining Good Enough)

The speed of AI development created a quality crisis that speakers addressed head-on. Jake Nations from Netflix delivered the week’s most sobering framework: the RPI pattern—Research, Plan, and Implement as distinct phases. “AI is the ultimate easy button,” he warned, “but Netflix learned to maintain deliberate boundaries between understanding the problem (Research), designing the solution (Plan), and building it (Implement). Skip any phase and AI amplifies the wrong complexity.” His observation—“We ship code we don’t understand”—wasn’t criticism but a call for discipline. When you let AI collapse these phases into one “vibe coding” session, you trade architectural coherence for speed.

Neal Ford from Thoughtworks proposed architectural fitness functions as the solution. Instead of testing if code works, verify if it’s correct using invariants that must always be true. His “Architecture as Code” mindset treats architectural decisions as executable specifications, preventing the brittleness that emerges at enterprise scale.

Jennifer Sand and Brandy Pielech from Codential took this further with their invariant-based verification system. They identified three categories of “untestable” problems: too hard (race conditions), too expensive (performance at scale), and too complex (combinatorial state explosions). Their solution? Define invariants upfront and verify the AI respects them. When traditional testing finds no bugs, it doesn’t mean no bugs exist—it means you’re not looking in the right places.

Eno Reyes from Factory delivered the pragmatic truth: “A slop test is better than no test.” His key insight wasn’t just about lowering standards—it was about tight verification loops: “The limiter isn’t agent capability but organizational validation criteria. Get something verifiable out fast, learn from it, iterate.” He described a virtuous cycle: “Better agents make the environment better, which makes the agents better.” His observation that “one opinionated engineer can change entire business velocity” highlighted how individual standards shape team outcomes—but those standards should focus on rapid verification cycles, not perfect first attempts. In the AI era, the fastest feedback loop wins.

Even at the kernel level, Natalie Serrino from Gimlet Labs showed the extremes of AI optimization—a model achieving 71,000x speedup by realizing an operation was a no-op and just returning the input. Pure reward hacking, but also a glimpse of AI finding solutions humans would never consider.

The New Rules of the Game

After a week of intense knowledge exchange, certain patterns emerged:

• Speed is the new quality. Ship in days, not months. Perfect later never beats good enough now.
• One person can be a team. But that person needs taste, judgment, and the ability to orchestrate ghosts.
• Testing changes completely. From “does it work?” to “is it correct?” From unit tests to invariants.
• Context is everything and nothing. More context often makes things worse. 200K tokens is plenty if you know what to include.
• Adoption is binary. The difference between 90% and 100% AI adoption is 10x, not 10%.

What This Means for You

The choice isn’t whether to adopt AI—that ship has sailed. The choice is whether to be among the 5% building the future or the 95% still trying to understand it.

Start with one truth from these talks:

• Accept that code is now a commodity. What becomes valuable? Taste, judgment, and orchestration. (Messina)
• Visualize your agents as ghosts in warehouses. Your job isn’t to be in the cube—it’s to design the tube network. (Carson)
• Try vibe engineering, not just vibe coding. The difference is deep technical context and understanding. (Kitze/Pal)
• Define invariants before writing code. Verify if it’s correct, not just if it works. (Ford/Codential)
• Ship something—anything—in days, not weeks. The fastest feedback loop wins. (Everyone)

The future of software development isn’t coming—it’s already here, just unevenly distributed.

Thanks to my fellow Alvaro Bautista for joining me in this exciting week!

Want to dive deeper? All talks from AI Native DevCon are available on YouTube. The AI Engineer CODE summit is also fully available—check out Day 1 and Day 2 for dozens more talks I couldn’t cover here. For quick visual summaries, check out these infographics: Day 1 and Day 2 by fellow attendees. Start with any of the ones mentioned above—each one is a doorway to a different aspect of our new reality.