Scaling AI: Simplicity Over Better Models

Last month I sat in a room with a dozen engineering leads from companies running AI in production. Not demos, not prototypes—actual revenue-generating workloads. I asked what their biggest bottleneck was.

Not one person said “model quality.”

Every answer was some version of: our data is a mess, our infrastructure can’t keep up, or we’re burning GPU budget on workflows that don’t need it. A CockroachDB survey of over 1,000 tech leaders backs this up; AI workloads scale faster than the systems underneath them can adapt. And yet the industry conversation stays fixated on the next frontier release. It’s maddening, honestly.

TypeScript 6.0 Beta: Preparing for the Go Rewrite

TypeScript 6.0 beta dropped on February 11th, and honestly? The release notes read less like a feature announcement and more like a farewell letter. This release wraps up the JavaScript-based TypeScript compiler for good. The next major version — TypeScript 7.0 — ships the native Go compiler Anders Hejlsberg first announced almost exactly a year ago, on February 28, 2025.

The team chose 6.0 as the version to rip out everything that won’t survive the transition. They’re not being gentle about it.

Google Antigravity: Orchestrating the Next Phase of Agency

Full disclosure: I work at Google. Antigravity ships under our logo. Everything here comes through that lens, so calibrate accordingly.

I’m going to be candid about what works, what doesn’t, and where this fits among the growing pile of agentic dev tools. The worst thing I could do — for Google’s credibility and my own — would be writing a product puff piece. Nobody needs another one of those.

What Antigravity Actually Is #

Google announced Antigravity alongside Gemini 3 back in November 2025. The short version: an agent-first IDE. Not an IDE with agent features bolted on (that describes Cursor and Copilot, fundamentally). An IDE designed from scratch around developers defining tasks while agents execute them.

Talk: Architecting Multi-Agent Developer Workflows

I gave a talk recently on multi-agent developer workflows. The prep forced me to organize a lot of scattered thinking into something presentable, and honestly that exercise alone justified the talk. This post distills the core arguments and architectural patterns I covered — not a transcript, more like the cleaned-up version of my speaker notes plus some refinements I’ve made since.

The punchline, for those who want it upfront: multi-agent systems work when the problem genuinely decomposes into specialized roles. But the instinct to split everything into agents? Same instinct that over-decomposed monoliths into too many microservices circa 2016. The pattern helps when it helps; it hurts when applied out of habit.

State of Messaging 2026: The Future is Conversational

Bandwidth’s 2026 State of Messaging Report calls this the “biggest messaging transformation in a decade.” I’ve been on both sides of the RCS ecosystem — DevRel at Google building the Business Messages program, a stint as CTO at a GenAI startup, and now back at Google focused on RCS — and I think they’re underselling it. A decade? Try generational.

Here’s why, and where the real opportunity sits.

The RCS Gap #

One number matters more than all the others: 96% device coverage. Apple shipped RCS support in iOS 18; Android had it for years. That single move from Apple closed the last meaningful gap. Projections put active RCS users at 3.8 billion by end of 2026.

2025's Radical Frontend Shift: Rise of Agent Runners

A year ago, the AI-in-frontend conversation went roughly like this: Copilot writes your React components, ChatGPT scaffolds your Next.js pages, Cursor auto-completes your CSS. The AI was a faster keyboard. That was the whole pitch.

That’s not where 2025 ended up.

What actually happened was stranger — and I think more consequential. AI agents started living inside frontend architectures. Not as code generators that hand off to a human for the last mile, but as autonomous actors that monitor production, diagnose breakage, and ship fixes without waiting for anyone to approve a pull request.

Panel: RCS-Based Verification vs Insecure SMS OTPs

Here’s a number that should bother you: SMS-based one-time passwords remain the default second factor for the vast majority of consumer authentication flows. Banks, healthcare portals, government services, e-commerce platforms. Most still send a six-digit code over a protocol designed in the 1980s. No encryption. None.

NIST formally classified SMS OTP as a “restricted authenticator” in SP 800-63B Revision 4. That’s bureaucratic language for “we don’t trust this anymore, and neither should you.”

Cloud-to-Edge: Global Architectures for HealthCare

An ICU bed generates roughly 2,000 data points per second. Vital signs, ventilator readings, infusion pump metrics, waveform data from cardiac monitors. When a patient’s condition starts sliding, the clinical window for intervention shrinks to seconds.

So do you really want that data making a round trip to us-east-1?

The Latency Problem Nobody Can Ignore #

Cloud computing solved a lot of problems in healthcare. Centralized data storage, elastic compute for genomics workloads, accessible ML model training. But it introduced a new one that nobody budgeted for: latency that’s flatly incompatible with clinical urgency.

Supercharging ML and AI Dev Experience at Netflix

Every ML engineer I know has the same complaint. Notebooks feel great for exploration but terrible for production. Production pipelines feel great for reliability but terrible for iteration. Pick one, then spend the rest of your week fighting whichever you didn’t pick.

Netflix just shipped something that might actually fix this. Or at least make the fight less painful.

Spin: The Missing Piece in Metaflow #

Metaflow 2.19 introduced Spin, and honestly, it’s the kind of feature that makes you wonder why nobody built it sooner. The idea is dead simple: take a single @step in your production pipeline, pull it out, run it locally with full state from the parent step. Notebook-style iteration, but inside your actual production DAG.

Node.js 25: Native Stripping of TypeScript Types

Node.js 25 dropped yesterday. V8 14.1, faster JSON.stringify for large payloads, native Uint8Array base64/hex conversion. Solid release. But honestly, the headline for me is the TypeScript type stripping story finally reaching its conclusion.

Type stripping—Node.js natively running .ts files by ripping out type annotations at parse time—shipped unflagged in Node.js 23.6 but still carried the “experimental” label. With 25.2 (landing shortly after this initial release), that label goes away. Stable. No flags, no warnings. You run node script.ts and it just works.

Right-Sizing AI for the Edge: Power and Security Focus

There’s a default assumption in the AI industry that bigger wins. More parameters, larger context windows, heavier compute. For many tasks, that holds. Complex reasoning, multi-step planning, fine-grained code generation: those benefit from frontier-scale models.

But a huge chunk of real-world inference doesn’t need any of that.

Classifying a support ticket? Detecting anomalous sensor readings? Running intent recognition on a phone? Shipping 405 billion parameters to answer “is this a cat?” is not engineering. That’s waste.

Trillion-Row Creative Insights: Scaling Netflix Muse

Netflix published a deep dive into Muse, their internal platform that helps creative strategists figure out which artwork and video clips land with which audiences. The engineering caught my attention—not because the technology stack is exotic, but because it combines well-understood techniques (probabilistic data structures, precomputed aggregates, columnar storage) into something that serves interactive analytics over a trillion rows.

A trillion rows. Interactive latency. And the use case? Creative decision-making, not ad targeting or fraud detection. That contrast alone makes the architecture worth pulling apart.

MCP: Using Streamable HTTP for Real-Time AI Tool Use

If you’ve been building MCP integrations, you probably noticed the transport layer changed underneath you. The March 2025 spec update—version 2025-03-26—deprecated the HTTP+SSE transport in favor of Streamable HTTP. The change sounds minor. Swapping one HTTP-based approach for another. But the implications ripple through everything from auth middleware to deployment topology.

Let me walk through what actually changed, why it matters, and what you need to know if you’re building or maintaining MCP servers.

Panel: Infrastructure for AI Agents in Messaging

I moderated a panel last week on infrastructure for AI agents in messaging, and one observation kept coming up: the chatbot era taught us almost nothing useful about what’s coming next.

Those early bots — the “type 1 for billing, type 2 for support” kind — were basically IVR menus in a text box. Rigid decision trees. No real state management. No tool orchestration. No fallback beyond “I didn’t understand that, please try again.” You know the drill.

Human-on-the-Loop AI Control

I was in a meeting last month where someone from a financial services team walked us through their AI oversight process. Every automated trading decision above a certain threshold gets routed to a human reviewer. The reviewer checks the decision, approves or rejects, and the system proceeds.

“How many decisions per day?” I asked.

“About forty thousand.”

“And how many reviewers?”

“Three.”

Nobody laughed. I think because everyone in the room already knew the answer before I asked. The math doesn’t work. It never did, really, but we’re only now being honest about it.

Grok 4 Heavy & Anime Companions

xAI had a busy July. On the 9th, they released Grok 4 and Grok 4 Heavy — reasoning models that set new benchmarks across the board. A couple weeks later, they launched anime-style AI companion characters behind their SuperGrok paywall.

Same company. Same month. And I can’t stop thinking about what that says.

The Technical Side: Genuinely Impressive #

Let’s start with what works. Grok 4 scored 25.4% on Humanity’s Last Exam, beating Gemini 2.5 Pro (21.6%) and o3 (21%). Those aren’t rounding errors — they’re meaningful gaps on a test specifically designed to stump frontier models.

Collaborative Retrieval for Conversational RecSys

Recommender systems have a split personality problem.

On one side, you’ve got LLMs that can hold a conversation — parse nuance, understand when someone says “something like Inception but weirder” and actually get it. On the other, you’ve got collaborative filtering: decades of behavioral data showing that users who liked X also liked Y. Both are powerful. Neither talks to the other.

CRAG fixes that.

It’s a joint effort from University of Virginia’s VAST LAB, Cornell, and Netflix (published at WWW 2025). CRAG stands for Collaborative Retrieval Augmented Generation — the first conversational recommender system that actually combines LLM context understanding with collaborative filtering retrieval. Not in a hand-wavy “we use both” sense; in a structured, two-step mechanism that pulls collaborative filtering knowledge into the LLM’s prompt at inference time.

Kruti: Multilingual Indian Assistants for Everyday Tasks

Most AI assistants are built in English and then translated. Kruti wasn’t. It launched in 13 Indian languages from day one—and that distinction matters more than it sounds.

Krutrim is India’s first AI unicorn, valued at $1 billion and spun out of Ola by Bhavish Aggarwal. They launched Kruti on June 12th. It’s an “agentic” AI assistant, which these days gets slapped on anything that sounds fancy. But Kruti actually earns the label: it doesn’t just answer questions. It books cabs, pays bills, orders food, generates images. Real transactions through real APIs—not chatbot parlor tricks.

Frank Kschischang and the Future of Engineering Impact

Earlier this month, the University of Toronto named Frank Kschischang a University Professor — the institution’s most distinguished academic rank, held by fewer than 2% of tenured faculty. Unless you work in information theory or error-correcting codes, you’ve probably never heard of him.

You’ve almost certainly used his work.

The Invisible Layer #

Kschischang co-created factor graphs, a mathematical framework for representing and computing with complex probabilistic relationships. If that sentence made your eyes glaze over, let me put it differently: factor graphs are a foundational tool used in error-correcting codes that make your wireless communications work, in the LDPC decoders inside your WiFi chipset, and in the probabilistic models that underpin a growing chunk of robotics and machine learning.

Panel: Global DevRel in the Age of AI Documentation

I spent last week at DevRelCon New York and the shift in conversation was impossible to miss. Two years ago, every panel was about community building and developer experience. This year? Half the sessions were about one question: how do you make your platform visible to AI agents?

The developer discovery pipeline has fundamentally changed. It used to be simple: developer has a problem, searches Google, finds your docs, reads them, evaluates your API. That model still exists, but it’s no longer primary for a growing segment of developers. The new path is messier: developer has a problem, asks Claude or ChatGPT, gets a recommendation that either includes your platform or—more likely—doesn’t.

Node.js 24: The Krypton LTS Cycle Begins

Node.js 24 landed on May 6th. Two days in, I’ve already migrated one personal project and started testing at work. The release is dense — V8 13.6, npm 11, Undici 7, a simplified permission model — but the part that interests me most isn’t any single feature. It’s the pattern these features reveal.

Node is maturing. Not in the “it’s boring now” sense. In the “it takes infrastructure seriously” sense. And that’s exactly what it needs to do to stay relevant.

Spec-Driven Development at Enterprise Scale

Three weeks ago I wrote about the shift from code-as-truth to intent-as-truth and collaborative intent articulation. The response was interesting: individual developers got it immediately, but engineering managers kept asking the same question.

“How does this work at scale?”

Fair question. And the honest answer is: it’s messy.

Spec-driven development at the single-team level is relatively straightforward. You write an OpenAPI spec, generate client and server stubs, validate implementations against the contract, and iterate. Good tools exist for this. The workflow is well-understood.

AI Software Delivery: Collaborative Intent Articulation

Something changed in the past six months. I don’t think we’ve fully processed it yet.

I’ve been writing code professionally for eighteen years. For all of those years, one thing stayed constant: the code was the source of truth. Requirements documents got stale. Design specs drifted. Jira tickets turned into archaeological artifacts. But the code? The code was always right — because the code was what actually ran.

That assumption is breaking down.

Year of Missing ROI on GenAI Investments

Full disclosure: Google signs my paychecks. AI sits at the core of everything the company does. So understand the position this comes from — the enterprise GenAI ROI story ranks, for most organizations, as pure fiction.

Not for every organization. And not forever. But right now, in March 2025, the gap between investment and measurable return staggers. The industry’s collective unwillingness to talk about it honestly? That starts to feel irresponsible.

Judge: Scaling Tools for Volunteer Mobilization

Last weekend I sat on a judging panel for a disaster-relief hackathon here in SF. Twelve teams, forty-eight hours, one shared obsession: how do you get the right volunteer to the right place at the right time when everything’s falling apart?

I’ve been thinking about this problem since 2011. Back then I co-founded Doare.org in Rio, which became the largest donation platform for non-profits in Latin America. Donations, though — not coordination. The coordination piece is orders of magnitude harder, and watching these teams wrestle with it brought back a familiar frustration.

Building AI-Native Teams: Lessons from OpenAI Codex

I read about how OpenAI structures their Codex team last week, and something clicked that I struggled to articulate for months. The shift to AI-native engineering goes beyond giving developers better tools—it reorganizes around the assumption that AI participates in every workflow. Not an add-on. Not a plugin. A participant.

The Codex team operates with roughly 40 people: 1 PM, 2 designers, the rest engineers. They ship multiple releases per week, sometimes pushing four internal builds in a single day. Those numbers would sound like chaos at most companies. At OpenAI, that’s just Tuesday.

Panel: M2M Trust and the Security Gap in Agentic AI

I moderated a panel last week on machine-to-machine trust in agentic AI systems, and the conversation went sideways almost immediately. The plan was to discuss identity management frameworks. What we ended up talking about—for the better part of an hour—was how fundamentally unprepared enterprise security is for a world where AI agents act autonomously on behalf of organizations.

The core problem is simple to state and terrifying to think through: every AI agent needs an identity. Every identity is an attack surface. And we’re scaling agents faster than we’re scaling the governance around them.

SEMR Report 2025: AI Moves from Experimental to Essential

Jellyfish just published their 2025 State of Engineering Management Report, and one number jumped off the page: 90% of engineering teams now use AI coding tools. A year ago, that figure was 61%. Only 3% of respondents said they have no plans to adopt.

The adoption question is settled. The measurement question—wide open.

The Adoption Curve Collapsed #

I’ve managed engineering teams through several technology shifts—containerization at TaskRabbit, cloud migration at earlier companies—and none moved this fast. From “should we try Copilot?” to “everyone’s using something” in twelve months. GitHub Copilot leads at 42% adoption, but here’s the part that surprised me: 48% of teams report using two or more AI coding tools simultaneously.

Mastra: Empowering JS Devs to Build Agents in TS

If you’re a TypeScript developer who’s tried to build AI agents, you’ve probably felt the gravitational pull toward Python. LangChain, CrewAI, AutoGen—the mature agent frameworks all live in Python land. The JavaScript side has LangChain.js (a port, not a native design) and the Vercel AI SDK (great for streaming, thin on agent orchestration). The gap is real, and honestly? It’s been frustrating to watch.

Mastra is a new framework that aims to close it. Built by Abhi Aiyer, Sam Bhagwat, and Shane Thomas—the team behind Gatsby.js—it’s a TypeScript-first agent framework that just joined Y Combinator this month. I’ve been poking at it for the past week, and I want to share what I’ve found.

Ethical Standards and Trust in AI-driven CX

A friend of mine—let’s call her Clara—called her bank last week, spending twelve minutes explaining a billing issue to an agent that grew more confusing by the minute. Patient responses. Thorough answers. Technically accurate. Also not human.

She found out only after asking directly. The disclosure felt less like a notification and more like a caught-out confession.

She switched banks.

Extreme? Maybe on the surface. But the reaction had nothing to do with the chatbot’s quality—which was apparently fine. Deception drove it. Having an emotional conversation with something that wore a human mask without warning.

Done Software: The Future of Sustainable Stewardship

Lately I keep circling back to software that’s done.

Not dead. Not abandoned. Not deprecated. Done. Feature-complete. Stable. Doing exactly what it set out to do, with no urgent need to do anything else. The concept makes most engineers uncomfortable—our entire industry rests on the assumption that software must continuously evolve or die.

That assumption runs wrong, and burns people out.

The Cult of Continuous Development #

Open source has an update problem. We’ve internalized the idea that a healthy project ships frequently—new features, new releases, activity graphs that glow green. GitHub’s contribution graph literally visualizes this: green squares good, gray squares bad. A project with no commit in six months looks neglected, even when stable, secure, and doing the job perfectly.

TypeScript 5.7 Variable Init Logic

TypeScript 5.7 shipped on November 22nd, and buried in the release notes—between the new --target es2024 flag and path rewriting improvements—is a fix that’s bugged me for years. The compiler now detects when you access an uninitialized variable inside a nested function.

If that sounds minor, you haven’t hit this one yet. I have. More than once.

The Problem That Was Always There #

Here’s the setup. You declare a variable, intend to assign it later; then you reference it inside a callback or inner function before the assignment actually runs:

Vishing Attacks Increase by 442% via AI Cloning

Three seconds. That’s all a modern voice cloning model needs—just three seconds of your voice—to produce a replica convincing enough to fool your CFO, your IT helpdesk, or your mom.

I’ve been tracking this space since my DreamFlare days, when we were building entertainment products with generative AI. The speed at which offensive tooling has matured? Genuinely unsettling.

The numbers back it up. CrowdStrike’s threat intelligence team documented a 442% increase in voice phishing (vishing) attacks between the first and second halves of 2024. Not a typo. Four hundred and forty-two percent.

Node.js 23: Experimental TypeScript Stripping

Node.js 23 dropped on October 16, and buried in the release notes between the V8 update and the require() changes is the feature TypeScript developers have been asking about for years: native TypeScript execution. You can now run node --experimental-strip-types app.ts and it works.

Mostly.

The implementation is more interesting than the headlines suggest, and the limitations matter more than the blog announcements let on. Let me walk through what’s actually happening under the hood and why it matters (or doesn’t) for your projects.

OSI Releases Version 1.0 of Open Source AI Definition

Back in September I wrote about the headache of defining “open source” for AI models. The Open Source Initiative has now published their answer—OSAID v1.0, released October 28 at the All Things Open conference in Raleigh. I’ve spent the last ten days reading the definition, the endorsements, the criticism, and the reaction from companies whose models don’t qualify.

My verdict? It’s a necessary compromise that will make some people furious and make everyone’s procurement conversations slightly less painful.

Strategic Restructuring for AI-Centric Operations

Here’s a stat that should keep every CTO up at night: 92% of enterprises invest in AI, but only 1% have achieved scaled impact across their operations. Gartner estimates that 40-85% of AI projects never make it from proof of concept to production.

Those numbers aren’t a technology failure. They’re an organizational failure. And I’ve seen it firsthand.

The PoC Graveyard #

Every company I’ve worked with in the last year has an AI proof of concept. Most have several. They demo well. Leadership gets excited. And then nothing happens.

Defining Open Source AI: Solving a Million Headaches

Last month I burned two days evaluating “open source” models for a production use case at DreamFlare. By the end I was more confused than when I started — not about the models themselves, but about what “open source” even means anymore.

Traditional open source is straightforward: you get the source code, you can modify it, you can redistribute it. That definition has been settled for decades. But AI models aren’t source code. They’re trained artifacts; the “source” is really the training data, the training code, the hyperparameters, and the weights. Calling a model “open source” because you released the weights is like calling a compiled binary “open source” because you published the .exe.

The Decline of DEI Programs in High-Tech Leadership

Women Who Code shut down in April. Girls in Tech dissolved in August. Tech Talent Charter closed the same month. Three organizations that collectively supported hundreds of thousands of women and underrepresented people in tech—gone within five months of each other.

This isn’t a coincidence. It’s a pattern, and the data behind it is damning.

The Numbers #

DEI-related job postings declined 44% by mid-2023 compared to the prior year. By late 2023, the decline accelerated further. CNBC reported in December 2023 that Google, Meta, Zoom, and the company formerly known as Twitter all made significant cuts to their DEI teams and programs. Not trims. Cuts.

Agentic Interfaces vs Copilots

Every pitch deck I’ve seen this quarter mentions “agentic AI” somewhere in the first three slides. It’s the new magic word. Investors love it. Founders love it. Gartner named it their top technology trend for 2025, predicting that 15% of daily work decisions will be made autonomously by 2028.

I’m building AI products right now at DreamFlare, and I think most companies are getting this wrong. Not because agentic AI isn’t real — it is — but because they’re skipping the step that actually works.

AI Adoption Divide: The Global North vs. South

I grew up in Rio de Janeiro. My first startup ran on a shared hosting plan that went down every time it rained hard enough to flood the server room in Botafogo. That was 2010. The infrastructure has improved since then, obviously, but when I watch the AI discourse from San Francisco — all the breathless predictions about how AI will transform every industry — I keep thinking about that server room.

Replacing GBM Entry Points: Managing the July Deadline

Three days. That’s what you’ve got before Google yanks GBM entry points from Maps and Search on July 15.

If you haven’t started migrating, this post is your triage plan. If you started but aren’t done, keep reading anyway — there are gotchas I ran into that Google’s docs don’t mention.

I’ve been through this migration at DreamFlare. We relied on GBM for customer intake flows. The timeline is tighter than it looks.

AI-Driven Attrition in Data-Heavy Support Roles

The AI job displacement everyone warned about? It’s not happening the way people imagined. No dramatic announcements. No factory floors going dark. No headlines about a hundred thousand people being replaced by a single model.

Instead, someone on the customer support team quits and the position doesn’t get backfilled. A market research analyst retires and the team absorbs the work using GPT-4. A data entry contractor’s engagement ends and nobody renews it. The org chart shrinks by one, then two, then five — and nobody calls it a layoff because technically, nobody was fired.

Apple Announces RCS Support in iOS 18

Five days ago, about ninety minutes into the WWDC 2024 keynote, Craig Federighi mentioned — almost in passing — that iOS 18 would support RCS messaging. He spent roughly thirty seconds on it, giving it no demo, no deep dive, no explanation of why it mattered. Just a brief note that Apple would adopt the GSMA Universal Profile for rich messaging with Android users.

I waited for this announcement for years. Literally years. I worked on the RCS ecosystem at Google, where I saw firsthand how the protocol developed and why adoption mattered. I’ve written about the protocol, built tools for it, argued with skeptics about it. And when the moment finally came, Apple treated it like a footnote.

Crossing the Chasm: AI's Impact on Team Performance

Geoffrey Moore’s Crossing the Chasm came out in 1991. It describes what’s happening with AI adoption in engineering teams right now — with uncomfortable accuracy.

Here’s the framework: new technology gets adopted by innovators and early adopters (the enthusiasts), then hits a chasm. That’s the gap between early adoption and mainstream use that kills most products. Crossing it requires a fundamentally different approach — stop selling to enthusiasts and start solving a specific, painful problem for the pragmatic majority.

GBM Deprecation: Planning the Migration to RCS

Google’s finally pulling the plug on Business Messages. The timeline is tight: no new partner registrations after May 22, entry points vanish from Maps and Search by July 15, and the API starts throwing errors July 31.

I worked on the GBM ecosystem at Google before moving to DreamFlare, so this isn’t abstract for me. GBM served its purpose — it brought conversational messaging into Search and Maps where users were already hunting for businesses. But it was always an overlay on Google’s properties, not a native messaging channel. RCS Business Messaging is the bet Google’s consolidating around, and honestly? It’s the right call.

Infrastructure from Code: The Death of Traditional IaC?

Every couple of years, someone declares that Terraform is dead. The replacement changes — Pulumi, CDK, now “Infrastructure from Code” — but the thesis stays the same: writing infrastructure definitions separately from application code is busywork, and a sufficiently smart tool should just infer the infrastructure from the code itself.

It’s a compelling idea. It’s also mostly wrong, at least in 2024.

I’ve spent the past few months evaluating IfC tools for DreamFlare, and the landscape tells an interesting story about what happens when elegant abstractions meet production reality.

Node.js 22: Experimental ESM Require and V8 v12.4

The Node.js 22 release candidates have been floating around for a few weeks, and the headline feature is exactly what the community’s been screaming for since ESM first showed up: you can finally require() an ES module.

Well. Sort of. Behind a flag. And only if there’s no top-level await. But still — progress.

I’ve been running the RC against our codebase at DreamFlare to see what breaks and what actually gets easier. Here’s what jumped out.

RCS Useful in Emergencies (911)

Imagine you’re hiding in a closet during a break-in. You can’t speak. You need help. You pull out your phone and text 911.

Except you can’t — because your local 911 center doesn’t support text messaging. As of early 2024, only 53% of US Public Safety Answering Points (PSAPs) can receive texts at all. Nearly half the country has no text-to-911 capability. And the half that does? They’re stuck with SMS, a protocol designed in the 1990s that can’t send photos, confirm delivery, or share your precise location.

Developers Share What Helped Them Land New Roles in 2024

A friend of mine — senior backend engineer, twelve years of experience, ex-Stripe — applied to 340 jobs last fall. Got four callbacks. Two interviews. One offer.

That ratio would’ve been unthinkable in 2021. But in the post-layoff market of 2024, it’s become disturbingly normal. I’ve been on the hiring side at DreamFlare AI for the past few months, and what I see from the other end of the table confirms it: the market is brutal, the volume of applicants is staggering, and most of the advice floating around online is outdated.

AI-Generated Code: The Trust and Verification Gap

There’s this moment I keep seeing on my team. An engineer gets a Copilot suggestion. It looks right. It passes the quick mental check. They tab-accept and move on.

Twenty minutes later, a test fails. The bug trace leads back to that accepted suggestion — a subtle null handling issue the generated code glossed over.

This happens more than anyone wants to admit. And it scales.

The paradox in numbers #

Three statistics that, taken together, should alarm anyone running an engineering org:

OpenAI Codex: Structuring AI-Native Teams

Six months into building DreamFlare’s engineering team with AI tools baked into the daily workflow, some opinions have formed. A few of them are probably wrong. But the experience turned concrete enough that the lessons on structuring teams — when AI pair programming is the default, not the exception — deserve sharing.

The 55% number and what it misses #

GitHub published a study in September 2023 showing that developers using Copilot completed tasks 55.8% faster than those without it. The earlier academic study from February 2023 (Peng et al., published in collaboration with GitHub Research) found similar results across controlled task scenarios. These numbers get cited constantly; they’re real.

Post-COVID Layoffs: Framing the Industry Correction

I’ve been putting off writing this post because the topic is genuinely painful. People I know and respect lost their jobs over the past two years. Friends. Former colleagues. Engineers, PMs, designers who did nothing wrong except work at companies that hired too many people too fast.

But the framing I keep seeing — that tech is “in crisis,” that the layoffs represent some fundamental collapse — doesn’t match the data. And bad framing leads to bad decisions, for companies and for the people navigating this market.

Schema First TypeScript Design with Valibot

Yesterday’s post was about avoiding any. Today I want to talk about the next step: making your types actually work for you.

Here’s the problem. TypeScript gives you compile-time safety. Beautiful, precise types that catch bugs before you run anything. Then the compiler strips them all away. At runtime, that carefully typed User object is just a plain JavaScript object—and nothing stops malformed data from sneaking in through an API boundary.

The Product Manager Role: Lessons from the PM Debate

New year. I want to talk about the most contentious debate I saw in tech this past year — and somehow it had nothing to do with AI.

At Figma’s Config 2023 conference back in June, Brian Chesky told the audience that Airbnb “got rid of the classic product management function.” The internet went nuts. PMs panicked. Founders cheered. Twitter threads stretched for days. Hot takes piled up like laundry nobody wanted to fold.

Avoiding 'Any' in TypeScript: Why it Exists and Remedies

Last day of 2023, and I’m thinking about types. Specifically, the type that undoes all your other types.

I’ve been writing TypeScript since before it was cool (and through the years where it still wasn’t). Every codebase I’ve inherited or built has had any scattered through it like landmines. Some justified. Most not. At DreamFlare, we’ve been slowly de-mining our codebase this quarter, and I figured I’d share the patterns that keep coming up.

Dapr Graduation: Maturity for Distributed Systems

Spent the better part of two decades building distributed systems, and the recurring theme never changes: everyone reinvents the same infrastructure plumbing. State management, pub/sub messaging, service discovery, secret stores — every team builds their own version, usually poorly, and then maintains it forever.

Dapr ranks as the most compelling attempt I’ve seen to fix that problem at the application layer.

What Dapr actually does #

For those unfamiliar: Dapr (Distributed Application Runtime) offers a set of building-block APIs that abstract away common distributed systems concerns. You get a consistent interface for state management, publish/subscribe, service-to-service invocation, input/output bindings, and more — all without coupling your code to specific infrastructure.

AI Agents: The Transition from Chatbots to Actors

Last week one of our engineers at DreamFlare asked me a question that stuck: “When does a chatbot become an agent?” My first instinct — say something about autonomy — felt too clean. The real answer runs messier than that.

A chatbot reads. An agent reads and writes.

The distinction sounds simple, but software architecture reshapes entirely around it. And we’re right in the middle of that shift, watching it happen in real time, building pieces of it ourselves.

Rasa: Minimizing Complexity in Generative AI Bots

I’ve spent the past month evaluating conversational AI frameworks at DreamFlare. We’re building a GenAI entertainment platform, and the bot layer sits at the center of everything. So when Rasa launched CALM—that’s Conversational AI with Language Models—back in October, I paid close attention.

After a couple of weeks digging through docs and hacking together a proof-of-concept, I’ve got a verdict. Rasa made the smartest architectural bet in conversational AI right now. Not the flashiest. Not the most technically impressive. The smartest.

OpenTofu: The Community Fork of Infrastructure-as-Code

Back in August, I wrote about HashiCorp’s decision to switch Terraform from MPL v2.0 to the Business Source License. I said I was watching the fallout.

Three months later, the fallout has a name: OpenTofu — which arrived faster than anyone expected.

It also has a Linux Foundation home, 140+ organizational backers, 600+ individual pledges, 18 full-time developers, and a beta release that dropped just days ago. The community response moved fast — even by open-source drama standards.

MetriRank CPaaS Report: Ranking the Messaging Leaders

Metrigy published their inaugural CPaaS MetriRank report this month. The top spot went to Infobip.

Not Twilio. Not Sinch. Infobip.

If you’re not deep in the communications platform space, that result might surprise you. If you are, it probably doesn’t. I spent years working on the platform side at Google’s RCS Business Messaging team, and the CPaaS layer—the bit that sits on top of messaging protocols—was always the part of the ecosystem I found most fascinating. And the most misunderstood.

GitHub Universe 2023: The Power of Micro-Mentoring

Yesterday was the application deadline for GitHub Universe 2023’s micro-mentoring program. If you missed it—don’t worry. I’m not here to promote something you can no longer sign up for. I’m here because the model itself is worth stealing.

GitHub offers 30-minute virtual 1:1 sessions between students and GitHub employees ahead of their annual Universe conference (November 8-9 this year). They’ve been doing it for five consecutive years now. And honestly? It’s one of the most underappreciated ideas in developer community building.

TypeScript 5.2: using Declarations and Resource Mgmt

TypeScript 5.2 dropped yesterday. The headline feature is using declarations — automatic resource management via the TC39 Explicit Resource Management proposal. If you’ve ever written a try/finally block just to close a database connection, this one’s for you.

I’ve been tracking this proposal since it hit Stage 3 at TC39 earlier this year. The TypeScript team’s implementation is clean — really clean. Let me walk through what it does, why it matters, and yeah, where it falls short.

HashiCorp Terraform License Shift: Strategy vs Community

Two days ago, HashiCorp announced that Terraform — and all their products — would switch from the Mozilla Public License (MPL 2.0) to the Business Source License (BSL 1.1). The news dropped on August 10th and the internet hasn’t stopped arguing about it since.

I have complicated feelings about this one.

What Actually Changed #

BSL isn’t proprietary, exactly. You can still read the source code. You can still use Terraform for your own infrastructure. What you can’t do is offer a competing commercial service built on HashiCorp’s code without their permission. After four years, the code converts to MPL 2.0 automatically — the “change date” mechanism.

Llama 2: Why Local Inference in C Matters for Node Devs

Two weeks ago Meta released Llama 2 with a commercial license. That alone was significant — the first truly open large language model you could legally ship in a product. But the thing that got me out of my chair was what Andrej Karpathy did with it eight days later.

He wrote Llama 2 inference in ~500 lines of pure C. No libraries. No frameworks. No PyTorch, no CUDA, no nothing. Just C and math. The repo is called llama2.c, and it runs the 7B parameter model at about 18 tokens per second on an M1 MacBook Air.

Python Sample Upgrade for RCS Business Messaging

The rbm-api-examples repository on GitHub doesn’t get a lot of fanfare. No launch events, no blog posts from the comms team, no tweets from product managers. It just sits there—quietly being the first thing most developers touch when they start building an RCS Business Messaging agent.

I know this because I watched it happen for almost two years at Google. A developer would find the RBM documentation, click through to the samples, clone the repo, and—within about fifteen minutes—either succeed or give up. The Python sample was often the deciding factor.

Platform Engineering: Bridging the Dev/Ops Gap

“You build it, you run it.” That was the DevOps promise. Engineers would own the full lifecycle of their services — from writing code to operating it in production. No more throwing things over the wall to an operations team. No more “works on my machine.” Full ownership, full accountability.

In theory, this was liberating. In practice? It buried engineers under a mountain of operational complexity they never asked for and weren’t trained to handle.

Generative AI: Cognitive Industrial Revolution

The Industrial Revolution mechanized physical labor. Steam engines replaced muscle. Factories replaced workshops. The economic transformation took decades, displaced millions, and ultimately created more wealth and more jobs than the systems it replaced.

I think we’re at the start of something equivalent for cognitive labor. And unlike the original, this one is moving on a timeline measured in years — not generations.

The Numbers #

McKinsey’s latest analysis projects that generative AI could add $2.6 to $4.4 trillion in annual value to the global economy. To put that in perspective, the UK’s entire GDP is roughly $3.1 trillion. We’re talking about a technology whose economic impact — by McKinsey’s estimate — is comparable to adding another G7 economy to the world.

WGA Strike: The Battle Over AI-Generated Content

On May 2nd, 11,500 members of the Writers Guild of America went on strike. The usual issues are on the table: compensation, residuals, staffing minimums. But one demand stands apart from everything else, and it’s the one I can’t stop thinking about.

The WGA wants explicit contractual language preventing studios from using AI to generate or rewrite scripts. They want guarantees that AI-generated text cannot be considered “literary material” under guild agreements, and that no AI system can receive writing credit.

OSPO Survey: The State of Enterprise Open Source

The 2023 TODO Group survey results dropped recently, and one number jumped out: 66% of surveyed organizations now have a dedicated Open Source Program Office or some formal open source initiative. That’s a 32% jump from the previous year.

Two years ago, OSPOs were something you’d find at Google, Microsoft, Meta — the usual suspects. Big tech companies with the resources and the open source exposure to justify a dedicated team. The idea that two-thirds of organizations would have formal open source governance would’ve seemed optimistic at best.

Formula Racing: Pivot to Electric and Tech Success

I’ve been thinking about constraints lately. The kind that make you better instead of smaller.

Formula E started in 2014 as motorsport’s awkward experiment. The cars were slow compared to F1 — embarrassingly slow, actually. The races were short. The tracks were temporary street circuits in city centers. Nobody in the traditional racing world took it seriously; most coverage had a patronizing tone. “Electric racing. How cute.”

Nine seasons later, the Gen3 car produces 350kW (roughly 470 horsepower), hits 200 mph, and recovers up to 600kW through regenerative braking. That regenerative figure is wild — it means the car harvests energy during deceleration at a rate that would’ve been the total power output of the original Formula E car.

Node.js 20: Permission Model and Test Runner Stability

Node.js has always operated on a trust-everything model. Your code, your dependencies, your dependencies’ dependencies — they all get the same unrestricted access to the filesystem, network, and child processes. A malicious package in your node_modules can read your SSH keys, exfiltrate environment variables, or spawn arbitrary processes. No guardrails. No questions asked.

Node.js 20, released April 18, starts changing that.

The Permission Model #

The new --experimental-permission flag lets you restrict what your Node.js process can do at runtime. Want to prevent filesystem writes outside a specific directory? Done. Want to block child process spawning entirely? Also done. Worker thread creation? Controllable.

TypeScript 5.0: Standard ECMAScript Decorators

Eight years. That’s how long the TC39 decorators proposal took to reach Stage 3.

It started in 2014 — ancient history in JavaScript years — went through multiple complete rewrites, and finally stabilized in March 2022. TypeScript 5.0 shipped last month with support for the standard version.

If you’ve been using --experimentalDecorators (and if you work with Angular, NestJS, or MobX, you almost certainly have), this matters. The new decorators aren’t a drop-in replacement. Not even close.

GPT-4: The New Frontier of Intelligent Reasoning

Three weeks ago, OpenAI released GPT-4. I’ve been using it almost daily since, and something feels different this time.

Not the “oh cool, it writes poems” kind of different. More like the “wait, it actually understood what I was asking” kind. I’ve spent years working with language models in various capacities — GPT-4 is the first one where I regularly forget I’m talking to a machine.

The Bar Exam Thing #

Let’s start with the number everyone’s quoting: GPT-4 scored in the top 10% on a simulated bar exam. GPT-3.5 scored in the bottom 10%. Same test; same format. The jump happened in roughly four months of iteration.

Conversational AI Market Projections through 2030

I’ve spent the past two weeks drowning in market research reports on conversational AI. Here’s my takeaway before we even look at the numbers: they’re guessing. Sure, it’s sophisticated guessing—proprietary survey data, impressive methodologies, models with Greek letters. But still guessing. ChatGPT dropped three and a half months ago and rearranged the entire landscape. Any projection built before November 2022? It’s working from assumptions that no longer hold.

That caveat out of the way, let me show you what the guesses look like.

Smartcast and Null Safety: Influences from Kotlin to TS

Working at Google means living in a polyglot environment. Android teams write Kotlin. Web teams write TypeScript. Backend teams write a mix of Java, Go, and (increasingly) Kotlin. When you cross those boundaries regularly — and in DevRel, crossing boundaries is the job — you start noticing how ideas migrate between language ecosystems.

One migration that doesn’t get discussed enough: the convergence of type narrowing between Kotlin and TypeScript.

Kotlin’s smart casts #

Kotlin shipped smart casts from day one in 2016. The idea was simple and, at the time, felt radical compared to Java: if you check a type at runtime, the compiler should remember that check and narrow the type automatically.

Learning to be a Great Leader is a Marathon, not a Sprint

I almost called this post “Leadership Lessons I Wish I’d Learned Sooner” — then realized that framing misses the entire point. The lessons aren’t late. They arrived exactly when I was ready to absorb them, which is the whole problem with leadership development: you can’t speed it up the way you speed up a code deployment.

I’ve managed engineering teams for the better part of a decade now. Small teams (3 people at Backer), distributed teams (9 engineers across 4 time zones at TaskRabbit), and DevRel teams at Google spanning multiple offices. The contexts differ wildly, but one pattern has been consistent: the leadership skills that matter most are the ones that resist being learned quickly.

LLMs as Forensic Architects for Architecture Discovery

It’s New Year’s Day and I’m thinking about legacy code. Specifically, a conversation I had last week with a friend who just inherited a monolith. Two million lines of Java. The original architects left years ago. The documentation—such as it was—describes a system that no longer exists. The actual architecture is embedded in the code itself, visible only to someone willing to spend weeks reading it.

His question was simple: “Can I just paste chunks of this into ChatGPT and ask it what the architecture is?”

WebTV Enthusiasts: Keeping Vintage Tech Alive in 2022

There’s a guy on YouTube browsing the modern web on a CRT television using a WebTV set-top box from 1997. The page loads are glacial. The rendering is hilariously wrong—CSS3 was not designed for a device with 560 pixels of horizontal resolution. And yet I watched the entire 40-minute video with a stupid grin on my face.

I shouldn’t be surprised. I spent my early career working with the constraints of early web technology. There’s something deeply satisfying about watching people refuse to let old hardware die.

ChatGPT: The Natural-Language Rupture of 2022

One million users in five days.

I keep coming back to that number. Instagram took two and a half months to hit a million. Facebook needed ten. Netflix took three and a half years. ChatGPT did it in five days. And everyone I’ve talked to this week — engineers, product managers, even my dentist — has an opinion about it.

I’ve been working in and around conversational AI at Google for over a year now. I’ve seen impressive demos. I’ve built prototypes with language models. None of that prepared me for the visceral reaction people are having to ChatGPT. This isn’t excitement about a new product. It’s something closer to a rupture.

TypeScript 4.9: Narrowing Checks with the 'in' Operator

TypeScript 4.9 shipped a couple weeks ago, and most coverage I’ve seen focuses on the satisfies operator. Fair enough — satisfies is flashier. But the change I’m actually excited about? The improvement to type narrowing with the in operator. It fixes something that’s been bugging me for years.

The problem before 4.9 #

Say you’ve got a value typed as unknown and you want to check if it has a specific property before using it. Your natural instinct is:

GitHub Copilot Metrics: Coding 55% Faster

A 55% improvement in task completion speed. That’s the headline from GitHub’s recent study on Copilot, conducted with Microsoft’s Office of the Chief Economist. And honestly? My first reaction was skepticism.

Not because I doubt AI-assisted coding works — I’ve been using Copilot since it went GA in June. But productivity numbers that clean always make me want to read the fine print.

So I read the fine print.

The experiment #

GitHub recruited 95 professional developers and split them into two groups. One group used Copilot; the other didn’t. The task: implement an HTTP server in JavaScript. Simple enough to complete in a few hours, complex enough to require real engineering decisions.

The Movement to the Fediverse: Mastodon and Decentralization

My Mastodon account is three days old. I set it up on mastodon.social, tooted (yeah, that’s the verb) a brief introduction, and followed maybe forty people. The whole thing felt like Twitter circa 2008 — slightly clunky, earnestly enthusiastic, and populated almost entirely by tech people talking to other tech people.

The trigger’s obvious. Elon Musk’s acquisition of Twitter appears to be closing any day now — the deal’s reportedly imminent, possibly finalizing this week. And a significant chunk of Twitter’s user base — academics, journalists, tech workers — is loudly exploring alternatives. Mastodon’s the primary beneficiary.

AI in Commerce: Order Intelligence and Payment Security

When I worked at TaskRabbit, I sat next to the payments team during a fraud spike that cost us six figures in a single week. The pattern was clever—synthetic identities (fabricated personal details cobbled together from real data fragments) booking high-value tasks, paying with stolen cards, then disputing the charges. Our rule-based detection caught maybe 30% of the fraudulent transactions. The other 70% sailed through because the patterns didn’t match any rule we’d written.

Productivity: How to ship faster and on time

Managing both kinds of teams — on-time and perpetually late — taught me one thing above all. The talent gap between them ran roughly zero. The process gap ran enormous.

An uncomfortable truth in this industry: shipping speed ranks as a leadership problem far more than a technical one. Engineers love to blame late deliveries on “complexity” or “technical debt” or “scope creep,” and those factors are real enough. More often, nobody established clear boundaries around what “done” means, nobody surfaced blockers early enough, and nobody had the nerve to cut scope when reality diverged from the plan.

DALL-E 2: Moving Image Synthesis into the API

Last week, OpenAI launched outpainting for DALL-E 2. You take an existing image, and the model extends it beyond its original borders — generating new content that matches the style, lighting, and subject matter of what’s already there. The demos look magical. A Vermeer painting expanded to reveal the rest of the room. A photograph extended to show what was just outside the frame.

It’s impressive. But I keep thinking about something else entirely.

TypeScript 4.8: Better Type Inference in bindings

TypeScript 4.8 RC dropped about ten days ago and I’ve been poking at it since. Most of the attention has gone to the {} type intersection improvements, which are legitimately useful. But the change that excites me most is subtler: binding patterns no longer influence type argument inference.

If that sentence didn’t immediately make you say “finally,” you probably haven’t maintained a library with complex generic signatures. Let me explain why this matters.

Stable Diffusion: The Open Source AI Explosion

Something big happens in generative AI, and it has nothing to do with who makes the best images.

Stable Diffusion—a text-to-image model built by Stability AI, RunwayML, CompVis at LMU Munich, EleutherAI, and LAION—prepares to release its model weights to the public. Not behind an API. Not through a Discord bot. The actual model, downloadable, runnable on your own hardware. About 10,000 testers held the beta, with a broader research release to roughly 1,000 researchers expected any day now.

Finding the 6th Day: A Productivity Guide for Engineers

Here’s a number that keeps bugging me: the average engineer at a large tech company spends only 30-40% of their workweek on actual engineering work. The remaining hours vanish into meetings, Slack, email, context switching, and whatever passes for “alignment” this quarter.

That means in a 40-hour week, you’re getting maybe 16 hours of real output. Two full days, gone.

After years managing engineering teams — at TaskRabbit, at Google — the pattern holds consistent across companies, team sizes, and seniority levels. Smart people sit down to write code, get interrupted, attend a meeting that should have stayed a doc, get interrupted again; by 4pm the day has accomplished roughly nothing.

Midjourney and the Rise of Generative Media

I woke up this morning and generated a Renaissance painting of a cat in a spacesuit. It took about sixty seconds. The cat looked contemplative.

This is where we are now.

Midjourney opened its beta to the public today, and if you haven’t tried it yet, the onboarding experience alone tells you something about where generative AI is headed. You don’t download an app. You don’t sign up for a waitlist (well, not anymore). You join a Discord server; you type a text prompt in a chat channel; you wait. And then an image appears that didn’t exist thirty seconds ago.

ADRs as Feedback Loops for Distributed Performance

I wrote about Architecture Decision Records a while back. Back then, I saw them as documentation—a way to capture the why behind decisions so future teams wouldn’t repeat past mistakes. Useful, sure. But kind of… administrative?

I’ve changed my mind. Or rather, I’ve realized I was only seeing half the picture.

At Google scale, working with distributed teams scattered across time zones, ADRs turned out to be something else entirely. They’re feedback loops. And that distinction matters more than I expected.

Scaling AppSec at Netflix with Cosmos Microservices

Netflix launches new microservices daily. Not weekly. Daily.

When your architecture is thousands of services deep and growing at that pace, you can’t secure it with manual reviews and quarterly audits. You just can’t. The only viable strategy is automation plus queryable data, and Netflix’s engineering team has written openly about how they’ve built exactly that.

Their Scaling AppSec blog post lays out an approach that I think any engineering leader running a microservices architecture should study — not to copy Netflix’s specific tooling, but to understand the organizational model behind it.

TypeScript 4.7: Native ESM Support for Node.js

TypeScript 4.7 shipped yesterday, and the headline feature is one that was supposed to land six months ago: native ESM support for Node.js.

If you’ve been following this saga, you know the backstory. TypeScript 4.5 (November 2021) was supposed to include the node16 and nodenext module resolution settings. The TypeScript team pulled them at the last minute because the implementation wasn’t ready. That delay was frustrating for everyone who’d been waiting — the CJS/ESM interop story in Node.js has been a mess for years, and TypeScript not supporting it natively made everything worse.

Talk: Bringing Conversational AI to Search and Maps

In two days, I’ll be at Shoreline Amphitheatre in Mountain View for Google I/O 2022. I’m speaking, which still feels slightly surreal to type. The event runs May 11-12, hybrid format with virtual sessions, and the announcements this year are… significant.

I can’t share everything yet. But I want to give a preview of what I’ll be covering — specifically how conversational AI is reshaping the way people interact with Search and Maps. Not as some distant future, but as stuff that’s rolling out now.

Node.js 18: Native Fetch API and Experimental Test Runner

Node.js 18 dropped on April 19th, and for the first time in a while, I’m genuinely excited about a Node release. Not because of performance improvements or security patches — those are table stakes — but because of two features that address long-standing gaps in the platform: a global fetch API and a built-in test runner.

Both are experimental. Both have caveats. And both signal a direction for Node.js that I think is overdue.

Talk: Lucrative Conversational Commerce with Chatbots

I gave a talk recently on conversational commerce — the intersection of chatbots, messaging platforms, and actual revenue generation. Not the “chatbots are the future!” hand-waving that’s been circulating for years. The concrete business case: where the money is, which platforms are winning, and what implementation patterns actually drive results.

The short version? Conversational commerce isn’t speculative anymore. The market was around $41B in 2020 and is projected to hit $290B by 2025. That’s roughly 7x growth in five years. When a market moves that fast, you either figure out your strategy or watch competitors figure out theirs.

Cybersecurity Mesh: Moving toward Zero Trust Designs

Gartner loves naming things. They’ve built an entire industry around it — the Hype Cycle, the Magic Quadrant, the annual list of Strategic Technology Trends that every CTO feels obligated to reference in their board deck. But occasionally, buried under all that branding, there’s a genuinely useful architectural concept. Cybersecurity Mesh Architecture (CSMA) is one of those.

CSMA made Gartner’s top strategic technology trends for 2022, sitting there alongside hyperautomation and autonomic systems. The headline prediction caught my eye: organizations that adopt a cybersecurity mesh architecture will reduce the financial impact of security incidents by an average of 90% by 2024.

Google Messages: New Connection Features for Android

If you’ve ever received a text from an iPhone user that reads “Laughed at ‘hey are you coming tonight?’” instead of just showing a laughing emoji — you know the pain. That little text description of a reaction is one of the most annoying artifacts of the Android-iPhone messaging divide.

Google just fixed it.

Yesterday, Google announced a set of updates to Google Messages that target exactly this kind of friction. They’re not flashy. They won’t make headlines the way a new Pixel launch would. But they’re the kind of quality-of-life improvements that make cross-platform texting — something most of us do dozens of times daily — significantly less awful.

Geopolitical IT Armies and the Role of Technology

Something shifted in the last 48 hours and I’m still processing it.

The geopolitical situation between Russia and Ukraine has been escalating for weeks, but what I want to focus on is the cyber dimension. Not because the physical dimension isn’t more important—it obviously is—but because what’s happening online represents a fundamental change in how technology intersects with conflict. And our industry is directly implicated.

The cyber front opens first #

On February 23rd, a major cyberattack hit Viasat’s KA-SAT network. The attack targeted satellite modems serving Ukraine, knocking out internet access across the country. But satellite beams don’t respect borders. The same attack disrupted Viasat terminals across Europe, including in Germany, where it knocked out remote monitoring of approximately 5,800 wind turbines operated by Enercon.

TypeScript 4.6: Improved Recursion Depth Checks

TypeScript 4.6 RC dropped on February 11th. Most coverage will focus on the shiny stuff—control flow analysis for destructured discriminated unions, the new --generateTrace flag, ES2022 target. Those are fine. But I want to dig into something most developers won’t notice: improved recursion depth checks.

It’s the kind of change that sounds boring until you realize it’s cutting type-check times in half for some libraries.

The old heuristic #

When TypeScript checks if two types are compatible, it sometimes hits recursive structures. Think Tree<T> = { value: T; children: Tree<T>[] }. Checking compatibility means recursively checking children, which means checking Tree again, and so on.

The Golden Thread: Managing Building Data Integrity

I rarely write about construction. But the concept emerging from the UK Building Safety Bill caught my attention—it maps so precisely to problems I spent years solving in software that I couldn’t ignore it.

The “golden thread” demands that every higher-risk building carry a continuous, authoritative digital record from design through construction through decades of operation. One source of truth, maintained throughout the building’s entire lifecycle because no single handoff point exists where someone else takes over responsibility. That sounds like a data lineage problem. Because it is one.