For thirty years, doing this to your editor was a Vim thing. Practically a personality disorder with a plugin manager. You bent the tool to fit you, and everyone else adopted whatever came in the box. That split, the tinkerers and the adopters, was stable for my entire career.

It just ended. Not because more people found Vim. Because building the exact tool you want stopped being expensive.

There’s a name for the tinkerer side, and it isn’t mine. TJ DeVries, who works on Neovim itself, calls it a PDE. Personalized Development Environment. He coined it to make a point: Vim was never an IDE, it’s a thing you bend until it fits one person, you, and only you. The term was built to describe the opposite of VS Code. Which is the whole joke, because VS Code is where this is happening now.

Three out of four developers use VS Code. 75.9% in last year’s Stack Overflow survey, ninth year running at number one, and that undercounts it, because Cursor, Windsurf, and the whole wave of AI editors people are switching to are VS Code underneath, forks of the same open-source core. A hundred thousand extensions in the marketplace as of May. A hundred thousand ways people have already bent the default until it stops being anyone’s default. The tinkerer instinct TJ was describing in a niche editor now sits under three-quarters of the profession. Most of them just don’t know they’re allowed to use it.

I found out I was allowed at work, building agents.

The project I spend my days on runs eight code-review agents on the same diff at once. Seven I wrote, an eighth hands off to CodeRabbit. Architecture, security, concurrency, database performance, each one a specialist reading the change in parallel, an orchestrator merging what they find and dropping the low-confidence noise so I’m not drowning. Here’s the part worth staring at: the seven agents are seven markdown files in a folder. The hard part, the thing that sounds like a product, is text shaped like colleagues, and the CLI just reads it. Once you’ve seen that, you stop waiting for anyone to build it for you.

So the interesting question stopped being which tool to adopt. Look at what exists for running many agents at once: cmux, herdr, Conductor, the orchestration baked into Cursor and Windsurf. They’re good, and they’re all the same signal, the tools racing to hold your fleet of agents. I’m not betting against any of them. I’m saying I didn’t have to pick one.

I wanted my agents living in the editor, in tabs, next to the code, not in a separate window I check like a build server. So one afternoon I built that. A keybinding, a picker, each agent opens in its own tab with its own icon and its own color, Claude and Aider and Codex side by side, the ones I run most floating to the top. It runs on Cursor and Windsurf too, because they’re the same editor underneath. I didn’t file an issue. I didn’t wait for a roadmap. The distance from wanting it to having it was one evening.

I should be honest about how far it goes, which is not very. Right now it launches agents and then forgets about them. The tab that would make it actually useful, one that shows every agent and what it’s doing so you can watch the fleet without leaving the window where you’d fix what it broke, I haven’t built yet. That’s next. So take the confidence with the appropriate discount.

For most of software history, if you wanted your tools to work differently you had two moves: switch to something else someone built, or file a request and wait. Building it yourself was a real third option, and almost nobody took it, because it cost more than it was worth. That’s the part that changed. The cost fell through the floor, and it took the whole build-versus-adopt calculation down with it.

The story here isn’t which agent tool wins. It’s that the gap between wanting a tool and having it collapsed to an evening, and most of us are still standing in the line we’ve always stood in.

The word came from the editor that refused to be an IDE. It turned out it was never really about the editor. It was about who gets to decide how your tools work. For thirty years that was a small club. The door’s open now, and admission costs an afternoon.

TJ DeVries coined “PDE” for the editor that isn’t an IDE. The idea outgrew the editor.

Until today, if you’d asked me why 72, my answer would have been that it feels right. That it sounds cool. Nothing I could defend with a straight face.

So I spent an entire evening doing the math to defend a “vibe”. The question: take the things that actually matter on a typical Indian highway (stopping in time, good fuel economy, safe distance from the vehicle ahead, traffic flow), work out the speed range each one allows, and see where they overlap. I expected a wide, boring band, maybe 60 to 90, with 72 sitting somewhere in the middle. But that isn’t what happened.

Stopping distance

Stopping distance is reaction distance (how far you travel while your brain registers “brake now”) plus braking distance:

stopping distance = v·t + v² / (2·g·f)

With t = 2.5 seconds (the standard cautious value from road design), g rounded to 10, and f = 0.40 for a decent NHAI surface:

60 km/h  →  76 m
70 km/h  →  96 m
72 km/h  → 100 m
75 km/h  → 106 m
80 km/h  → 117 m
90 km/h  → 141 m

Look at 72. Reaction: exactly 50 m. Braking: exactly 50 m. Total: exactly 100 m. I spent ten minutes staring at those numbers, feeling like the second coming of Ramanujan, convinced my vibe was actually a latent mathematical genius.

NH48 is not an expressway, or even a proper highway by definition. It has craters bigger than the moon, crests with enough altitude to spill your coffee, curves blind from all angles, and the occasional cow crossing. It’s not a place to be doing 100 km/h. Past roughly 100 metres of required stopping distance, you’re gambling. That knocks out 85 and above. The first boundary is set: 60 to 80.

Small engines and gearing

Most writing about fuel-efficient cruising speed is American. They talk about peak efficiency near 55 mph, measured on lazy, turbocharged engines with tall gearing. Indian cars are different. My daily driver is a 1.2L, naturally aspirated Swift. The ARAI-rated fuel economy is 23 kmpl, a number produced in a lab by a machine that had nowhere to be. On actual highways, owners report 19 (pre-E20 era) or 17 (post-E20).

What the Team-BHP ownership threads agree on is that a small NA petrol peaks lower than you’d guess, somewhere between 60 and 80 km/h, and starts sagging well before 100. A 1.2-litre engine holding 100 km/h isn’t cruising. It is me at the end of a 10k run: out of oxygen, gasping, and probably at 80 dB if measured. The second boundary: 60 to 78.

The closing-speed trap

Previously, my instinct was to cruise well above truck speed so I was never stuck near them. That is backwards. On the busy stretches of NH48, the ones that cause all the braking, trucks settle into 60 to 70. If I’m doing 88 behind a truck doing 65, I’m closing at 23 km/h. The gap vanishes fast and I get a forced decision: brake now or overtake now. That is exactly the ragged driving I am trying to escape.

A small closing speed does the opposite. I gain on the truck slowly, see the decision coming from far back, and half the time the truck’s own gap opens up before I touch the brakes. The target isn’t a safe distance from trucks, it’s a gentle closing speed: 5 to 10 km/h above their band. On empty stretches, trucks do 80 or 90, but overtaking there is easy. The third boundary: 70 to 75.

Dividing by 3.6

Inside 70 to 75, here’s what made me sit up. Converting km/h to m/s means dividing by 3.6, so a speed is a whole number of m/s only if it’s a multiple of 3.6. The nearby multiples of 3.6 in our range: 68.4, 72.0, 75.6. Only one sits inside our acceptable range.

72. Exactly 20 m/s. From there every mid-drive calculation comes out whole: reaction distance 50 m, braking 50 m, two-second gap 40 m, three-second gap 60 m, 100 m every five seconds. Nothing left over anywhere.

The compromise

I noticed, partway through, that I took a lot of liberties with the numbers. They are realistic, but I selected them because they were clean and suited my vibe, not because I ran a braking test on NH48.

The three boundaries are mine too. Nudge each by a few km/h and you get a slightly different window. But 72 remains.

I still set the cruise control to 72. Not because of the math, but because at exactly 20 metres a second, the highway stops feeling like a combat zone. The overtaking decisions make themselves, the car doesn’t complain, and I can listen to Kishore Kumar in peace. The math is just the excuse I write down so I don’t have to admit I just want the quiet. But at exactly 20 metres a second, the road stops being a threat. It is just space moving past at a speed I can keep up with.

A man living on the frontier loses his horse. His neighbors gather to sympathize. Bad luck. He shrugs. “Maybe.”

The horse comes back, leading a second, finer horse. The neighbors come back to congratulate him. Good luck. He shrugs. “Maybe.”

His son starts riding the new horse, gets thrown, and breaks his leg. The neighbors come back to mourn his bad fortune. He shrugs. “Maybe.”

Then war breaks out, and every able young man is conscripted and sent to the front. The son, with his broken leg, is left behind.

The parable has a name in Japanese: Saiō ga uma, “the frontier old man’s horse.” It’s older than that, Chinese, around two thousand years old, and it passed into Japanese as a four-character idiom for exactly one thing. You can’t tell yet whether something is good luck or bad. The verdict hasn’t arrived. That’s the whole point of saving it.

I treated my JEE rank as bad luck for years. Not enough to land a circuit branch at a top IIT, which is the whole point of the exam if you grow up where I did. I went to BITS Pilani instead. A very good college. I knew that then. It didn’t feel like enough.

Here’s the part I missed for a long time. I’d been so fixed on the tag, the letters IIT, that I never asked the only question that mattered: I was going to study that stream for four years. Did I actually want to?

The rank that closed the circuit-branch door is the same rank that left me free to pick the subject I’d quietly been drawn to. Mathematics. The thing I’d have talked myself out of for a better-known name on a sweatshirt. What felt like the worst luck at eighteen turned out to be the moment the choice got handed back to me.

I’m not pretending it was painless at the time. It wasn’t. I sat with it for a while before it turned into anything.

The frontier old man’s trick isn’t optimism. He never says it’ll be fine. What he does is refuse to stamp the verdict too early, because the verdict keeps moving. The neighbors keep showing up with their condolences and their congratulations, and every single time, they’re wrong about something.

I still catch myself calling things bad luck the week they happen. A rejected application, a plan that collapses. I’m the neighbor. I want to know now. The parable says I can’t, and I’m starting to believe it.

The horse ran away. Maybe.

The bad luck was just the luck, a few years early.

Most came back with a “thanks.” A few came back with “love you bro.” If you know any emotionally unavailable mid-20s Indian men, you know that’s the highest compliment physically possible. We are a nonchalant final boss. “Love you bro” from us is a Nobel acceptance speech.

Here’s what I keep turning over though. If I’d done the formality version, the postcard equivalent of a forwarded meme, I’d probably have gotten the same replies. “Thanks man” comes free. The “love you bro” might have come anyway.

The extra effort wasn’t what earned the reactions. They would have come anyway. But here’s the part I didn’t expect. Sitting down to write fifteen postcards by hand, one full day, each one actually different, I felt proud. Not of the postcards. Of the version of me who chose to do it that way. And when the “love you bro”s came back, I felt loved, and appreciated, in a way a forwarded meme has never made anyone feel.

That good feeling is the part nobody talks about. And it’s the whole point.

The last 5%

I’ve started noticing a part of every task that nobody asks for and almost nobody does. I’ve been calling it the last 5%. It doesn’t move the outcome. It moves everything else.

It showed up loudest in arguments. I’m competitive on the inside, not the loud kind, the table-tennis-at-zonal-level kind, still wired somewhere to win the point. So I wasn’t really listening, I was loading my rebuttal while the other person was still talking. The shift only came when I let myself see that the people arguing with me were arguing for my betterment.

A few more, from the last few months. A travel agent I went back and forth with for days over a Spiti trip, until the deal fell through. The easy thing was to ghost. He’s a stranger on the internet, the transaction’s dead, why bother. I sent three sentences instead: thanks for the time, here’s why it didn’t fit, ping me if a better window opens. Forty seconds. Changed nothing about the trip.

In Spiti itself I stayed at small homestays where people had bet everything on the place. After checkout the easy thing is to vanish, so I sat down and wrote detailed reviews, with photos, for every stay and every cafe owner who was kind to me. The woman who served me hot chocolate and a brownie will probably never connect the review to the quiet guy in the corner.

What I think is actually happening

Here’s the thing I keep turning over. None of these improved the task. The postcards didn’t make me a better friend in that moment. The travel agent message didn’t get me a cheaper trip. The reviews didn’t earn me a discount.

What they did was cast a vote. Each one says: I’m the kind of person who finishes things properly, even when nobody’s watching, even when it doesn’t matter. And votes accumulate. One is worth nothing. A hundred is a different person.

Doing things well, as far as I can tell, isn’t a quality strategy. It’s an identity strategy. The point of the well-written message isn’t a better message. It’s that you become someone who writes messages like that, and that person writes better, codes better, lifts better, listens better, shows up better, because they’re not a different person in each room. The standard travels with you.

I used to think I had separate dials. Work at 90, gym at 40, relationships at 60, dishes at 20. I assumed they were independent. Lately I’m not so sure. If my morning gym session was phoned in, I don’t feel right the rest of the day. Something’s off and I can’t quite name it. And no matter how good the food is, a meal eaten out of a badly-arranged, dirty kitchen doesn’t taste good to me. The low standard in one corner contaminates the felt quality of everything else. The standard isn’t parcelled out by room. It’s one dial. And I can’t quarantine the low settings. They bleed into how the whole day sits in my body.

This isn’t “do everything perfectly.” Perfectionism is a different disease, and it ships nothing because nothing is ever ready. The last 5% thing is the opposite. It’s about finishing, properly, and moving on. Perfectionism says it’s not ready. The last 5% says it’s ready, I did it right, next.

The test I’ve been running on myself: could I find one more minute to make this better, and would future-me be glad I spent it? Usually yes. Sometimes no, and then I ship. I’m still figuring out which is which. I default to yes because I haven’t earned the right to say no yet. The people who default to no aren’t being efficient, I think. They’re just practicing a different identity, and getting very good at it.

I don’t do any of this because you’ll notice. You won’t, most of the time. I do it because of that feeling in Hikkim. The postcards weren’t for the replies. They were for the version of me who sat down and wrote them, and that version is the one I’m stuck with for the rest of my life.

There’s an old line, i think it comes from Zen, How you do anything is how you do everything. It used to sound like a threat. Now it sounds like the most generous thing I’ve ever read. It means the postcard matters. The gym set matters. The message to the travel agent matters. Google review matters. Not because the world is keeping score, but because you are always, in every one of them, rehearsing and becoming someone. You might as well become someone who does things right!

I spent a while going after this. Reading, catching myself mid-decision, writing down the places I’d been confidently wrong. The first thing I learned is that the lies aren’t random. They come in patterns. Once you see them, you can’t unsee them.

Here are three of its favourite lies.

Bias #1: Survivorship bias, your brain only counts the winners

Steve Jobs did it. Zuckerberg did it. Gates did it. Dropouts, all of them, and your brain connects the dots: dropping out is the move.

What it doesn’t connect is the millions who dropped out and now make less than their graduating classmates. Nobody writes a magazine profile about that guy.

But here’s the half of survivorship bias nobody talks about. It’s not just the failures you don’t see. It’s most of the successes too.

I work at a company called Procol. Real business, real revenue. You’ve never heard of it. You wouldn’t recognise the founders if they were standing next to you in a lift.

The founders everyone can name are famous for being famous, not for building the most. The actual economy runs on companies you’ve never heard of, and my brain keeps pointing at the famous three and calling that the data.

I catch myself doing the same thing with startup founders. I’ll read about someone who quit their FAANG job, built a SaaS, and hit $1M ARR in 18 months, and my brain says “that could be me.” What it doesn’t say: for every one of those stories, thousands quit, burned through savings, and quietly went back to job hunting. I just never meet them, because they don’t post about it on LinkedIn.

The media doesn’t report reality. It reports interesting deviations from reality. And my brain treats those deviations as the norm.

Bias #2: Sunk cost fallacy, throwing good after bad

The clean version first. You buy a movie ticket for $20. Fifteen minutes in, you know it’s garbage. Do you leave?

Of course not. You sit there for another two and a half hours because you already paid. Here’s the math your brain refuses to do: that $20 is gone whether you stay or go. By staying, you’re spending more time on top of it. If your time’s worth $20 an hour, you just spent $50 to “recover” $20. A $20 mistake now costs you $70, and $50 of that was voluntary.

This is the one bias I’m actually good at, and it shows up in the smallest place. I start a book. A hundred pages in, it’s not getting better, or it’s just not my taste, for a thousand different reasons. I drop it. Why spend any more time on it. The $20 is gone. Walk out.

Books are easy, because the cost is small and the exit is clean.

Then there’s the version you can’t price. Relationships. You can’t put a number on emotions, which makes sunk cost fallacy almost impossible to see in real time. You’ve invested six months, a year, three years. You know it’s not going anywhere. But leaving means all that time was “wasted,” so you invest another year. And another.

The thing I learned, the hard way, is that familiarity and love are two different things. They feel similar enough that you can spend years confusing one for the other. The math is identical to the movie ticket: the cost is already sunk, the only question is whether you keep paying. Except you can’t see it, because there’s no receipt.

Bias #3: Confirmation bias, seeing what you already believe

I was watching vlogs by Paramvir Beniwal, a travel YouTuber who’s been to over a hundred countries. One of them was from a village in Africa, and the thing that hit me was how much it looked like a village in a poor part of India. Same kind of houses, same kind of dust, same kind of people getting on with their day.

So I looked it up. Per capita income in that part of the world is in the same band as Bihar, around $880 a year. Girls’ education, for every ten years boys spend in school, girls spend about nine. The numbers weren’t the catastrophe I’d been carrying around in my head.

Here’s what I realised about my own head. I’d absorbed one Africa, the one on the news, which only shows up for famines, wars, and coups. My brain had filed the whole continent under “uniformly terrible,” and every headline confirmed it. A travel vlog was the first time I’d looked at the same place from a different angle, and the picture wouldn’t hold.

That’s confirmation bias. Not a bad dataset, but a dataset you only ever look at from one side. Every fact that fits, you nod at. Every fact that doesn’t, you find a reason to dismiss.

There’s a line in Factfulness that lands differently now. The authors describe couples across the United States, Iran, Mexico, Malaysia, Brazil, Italy, China, Indonesia, India, Colombia, Bangladesh, South Africa (different languages, different scriptures on the nightstand) and they’re all doing the same thing in their bedrooms. Whispering about their dreams for their kids’ future.

Every language has a word for “happy.” Every language has a word for “grief.” That’s not a coincidence. It’s evidence that humans run on nearly identical hardware, and most of what we think divides us is just what we haven’t looked at closely enough.

I’m not saying the world is fine. It isn’t fine in the village I saw in that vlog, and it isn’t fine in Bihar either. But the world isn’t as bad as the news needs it to be. It’s also not as good, everywhere, in uniform. It’s somewhere in between, and you only find where by actually looking.

So what do I do with this?

I don’t have a cure. The brain still lies. But I’ve got three questions I run on myself now, one per lie.

When a success story sounds too clean: how many people tried the same thing and failed, and how many succeeded without anyone noticing?

When I’m holding on because I’ve “already invested so much”: if I were starting fresh today, would I make the same choice?

When a belief feels obviously true: what data would change my mind?

If I can’t answer that last one, I’m not thinking. I’m just confirming.

“Happy is the person who can improve others not only when present but even in their thoughts.”

Read that again. There are people who make us better when they’re around. Then there are people who make us better just by existing in our memory. You’re about to do something you wouldn’t want them to see, and their face pops into your head, and you stop.

It hit me hard because I’ve felt this. Last week I was fighting with my younger brother over text. He’s five years younger, and somewhere along the way he built a picture of me that’s better than I usually am. I had a reply ready that would’ve won the argument and cost me a piece of that. Right before I sent it, his face came to mind, and I deleted it. Not because he’d catch me or punish me. He can’t do either. I’m older (and much stronger!). Because I wanted to be who he already thinks I am.

It’s not the same as religion’s universal watcher concept, where fear of being seen keeps you in line. Fear makes you hide the worst of you. Love makes you reach for the best. Same watcher, different engine.

The Stoic who wrote that line called it happiness. I’d call it borrowing a face you trust until your own grows into it.

I don’t count imaginary scores anymore. Sometimes I lose a rally on purpose now, just to keep the game going, because the game is the point. Noticing that shift is what got me thinking about how you’d even measure something like personal growth in the first place. If I’d quietly gotten better at the one thing I’d been bad at my whole life, what else could you actually track? And who else thinks about this?

Some friends told me this whole exercise is mildly sociopathic. Why measure everything? Life is to be lived, not scored. They’re not wrong, they’re just asking the wrong person to stop. I’m a mathematician and an athlete at the core. I will always keep score. I will always want the win. I’m going to measure, whether I decide to or not. So the question was never whether to measure. It was what to measure. Net worth and follower counts aren’t what I live for. This post is me trying to point that instinct at the right numbers. It’s me trying to mend me.

Rate of change

I have this theory that life has a circadian rhythm. Every 3-6 years, you become a different person. You work on different problems. Your lifestyle changes. The people you hang out with are different. If you haven’t caught up with a friend in 5 years, you might no longer have anything in common. It’s not a coincidence that schools are structured into chunks of 3-6 years.

I can see it in my own life, chapter by chapter. Table tennis. Competitive maths. Engineering school. Each one a different person, each one barely recognizing the last. And then, for almost two years, I was nobody in particular. Between versions, with no next one in sight. I’d come out of a structure that told me who I was every morning, and for the first time nobody was handing me one. I didn’t handle it well. It was only recently that I felt like I had a handle on life again.

I wonder if I could treat myself like an investment, and measure my growth by how long it’d take me to become a new person.

Finance has a name for this. The rule of 72. Divide 72 by your annual return and you get the years it takes to double. 8% a year, and your money doubles every nine. What I want to know is the return on me. How long until the version I’m living as now is unrecognizable to the one who started?

Becoming a new person isn’t always a good thing, and probably not the goal for everyone. But for me, it is. I want to see things from a new perspective. I want to be exposed to new challenges.

Becoming a new person sounds clean. It isn’t. It feels like outgrowing a room you used to love, walking back in years later, and finding the ceiling too low to stand up straight in. You can’t un-grow. Some of my oldest friends are rooms I can’t stand in anymore. We still talk, I still love them, but I catch myself performing the old version of me so the conversation has somewhere to land, and we both feel the draft coming through the gap. The growth and the loss are the same event. I haven’t figured out how to want one without getting the other.

Time to solve problems

Mayank, an old friend doing his post-doc at Cambridge, frames it like this. Most people walk into three big problems after college, and spend roughly a decade on each. First, figuring out what you want to do with your life. Then marriage, a house, kids. Then savings, and the slow climb toward retirement. He calls them life projects. His goal is to close his faster, so he can get to more interesting ones. I realized I’d been quietly running the same race without ever naming it.

This made me think that perhaps I can measure my growth by looking at what big problems I’ve solved. What big problems was I worried about 5 years ago that I no longer worry about now? What big problems am I worried about now that I don’t want to worry about in 5 years?

What counts as a big problem depends on the person. For me, it’s career, finance, family, and health.

Five years ago the college kid in me panicked about money constantly. Every UPI notification was a small heart attack. That went quiet the day there was finally a real safety net behind me, and I didn’t notice the silence until months later. I used to want a place that was actually mine, in a big city, actually safe. That’s sorted now. My parents’ health used to send me into a spin with every little niggle. The niggles still come. I’ve just gotten better at carrying them without letting them flatten the whole week.

Some things quietly stopped registering as threats at all. Performance reviews used to cost me three days of low-grade dread each. Now they don’t cost me much. I didn’t fix that on purpose. I looked up one day and the fear had moved out without telling me.

The big one is still open: what I actually want to do long-term, and where. My own company? A move to the US or Europe? That’s the weight I’d like to not be carrying five years from now. Writing that sentence down, in public, is the most honest thing in this post, because now I can’t pretend I haven’t noticed it.

Number of future options

A while back I read a theory on Twitter that every few years, half of your dreams die. People give up on their dreams because they realize they can no longer achieve them.

I disagree. As I grow older, I have more dreams. I now know many things that I didn’t know before, and I have access to more resources than I ever did. This allows me to do things that I used to think of as impossible. And the dreams keep multiplying instead of dying off. I keep a running list of a hundred things I want to do, and the giveaway is that I’ve crossed things off it and then deleted them anyway, swapping a goal I’d already hit for a bigger one. I can’t sit still, even with a win in hand.

During a reinforcement learning course in college, I learned there’s a name for how I’d already been living. Empowerment maximization. When an agent faces uncertainty, it picks the move that keeps the most doors open. Faced with a wall of switches, it pulls the one that unlocks the most others.

I didn’t need the jargon. I’d been doing it for years without a word for it. In the face of uncertainty, I lean towards the decision that gives me the most future options. I’d choose a job that pays less if it buys me more optionality: open source, papers, transferable skills over niche ones. I’d rather earn less now and keep the doors open behind me.

Perhaps I can measure my growth by how many new options I have gained/lost. What options are available to me today that were not available to me 5 years ago? What options were available to me 5 years ago that aren’t available to me now? More importantly, what options that are not available to me today do I want 5 years from now?

I came across this image from Wait But Why. As time goes by, many doors close to us, but many new ones open up. That tweet was talking about the red lines on the left. I keep my eyes on the green lines on the right.

Conclusion

I don’t know if these three metrics are right. I don’t think right is the point. They’re the ones I can’t stop watching.

I still play table tennis on office breaks and weekends. I still feel the old reflex twitch when someone pulls ahead, the imaginary scoreboard lighting up. But more often now I let the rally run long. I feed an easy one back, try a stupid loop just to see if it lands, lose the point on purpose, because a rally that ends early isn’t worth winning. That’s the one metric I trust most. Not the rate, not the problems, not the options. Just this: I can finally lose on purpose. A younger me would have called that losing. He’d have been wrong.

Maybe one day I’ll get tired of exploring and want to stay still. I used to think staying still was the failure. Now I think wanting to stay still might be the biggest change of all. When that day comes, that’ll be growth too.

It rained the morning we left Spiti.

Six days of hard blue skies, the kind that make you squint at your own photos later, and the valley picked our last day to rain. We stood next to our bus, bags fully loaded, nobody moving towards the door. Just standing there, feeling the drizzle, like the rain was saying something and it would be rude to leave mid-sentence.

Mountains don’t wave goodbye. They just rain.

But let me go back.

Day One: The Point Where Maps Become Decorative

The road from Shimla into Kinnaur is carved into the side of a cliff. Not metaphorically. Someone took a drill to a rock face several hundred meters above the Sutlej and decided that was a road now, and for sixty years everyone has agreed to believe him.

Our driver, a man of monk-grade calm, took these roads the way I drink coffee. Automatic. Present. Unbothered.

The rest of us had a more complicated relationship with the route. I won’t say we were scared. I’ll say we developed a sudden, collective interest in the view from the left side of the car specifically, and that someone turned on WhatsApp live location for a family group chat. I don’t know what we thought Gurgaon was going to do about a cliff in Kinnaur. It just felt important that they watch.

At one point the side mirror cleared the rock face by a margin we engineers call “acceptable”, but more commonly “bhaiya, itni side se mat lo!”

By Kalpa I had made peace with the roads. Convenient, because Spiti had five more days of them.

Kalpa: The Flags Pray Without You

Kalpa is where the trip stopped being a road trip and started being whatever it ended up becoming.

The prayer flags here don’t flutter, they spiral. Wind comes up the valley and the flags move like the landscape choreographed them. Each one is a prayer released into the air. I stood there trying to compute how many prayers had passed through that exact patch of sky over a few centuries, and concluded the math was not the point.

Kinnaur Kailash sat across the valley the whole evening, lit up like it knew. My camera captured it. My brain accused the camera of editing. The camera was innocent. The place just looks like that.

Tabo: Nobody Tells You About the Sky. That’s On Purpose.

The caves above Tabo are a twenty-minute trek from the village, up a trail that is marked the way secrets are marked, which is to say not at all. Monks used them for meditation for a thousand years. I climbed up at night with a lot of optimism in my phone’s camera capabilities.

Here’s what happened: I set up a twenty-minute timelapse of the sky, sat down on the cold ground, looked up, and didn’t say a word until the camera was done. Neither did anyone else. The starry night over Tabo isn’t a sight, it’s a ceiling. You think you’re prepared because you’ve seen photos and you consider yourself a person who appreciates a sky. You’re not prepared. It hangs there with absolutely no regard for what it’s doing to you. No camera can ever do justice to that!

The monastery below has murals over a thousand years old. The sky above has a few billion years on that. Both were watching us. Only one of us blinked.

Kaza: Four Seconds

I should be honest about what I thought I was doing in Spiti.

I thought I was the guy who does pushups at what the signboard insists is the highest motorable road in the world. Who jumps in slow motion at the highest café in the world. Who shows up at 4,500 meters and meets the altitude on his own terms. And to be fair, all of that happened.

The pushups happened at the top of the pass, in air thin enough that my lungs filed a formal complaint by rep six. I finished the set anyway. There’s something about effort at that altitude that strips the pose out of it. You’re not performing, your body is too busy negotiating with the oxygen for you to perform. It’s just you, the ground, and mountains watching with complete indifference.

The slo-mo jump at the highest café in the world was filmed, reviewed, and refilmed, and looked significantly more cinematic in my head than on camera. Gravity at 15,000 feet works exactly like gravity at sea level. I have no idea why I expected a discount!

Then, at our homestay in Kaza, the owner’s daughter who could not have been more than seven, challenged me to arm wrestling.

She had the energy of someone who had done this before. I realized mid-lock that she absolutely had, that I was not her first tourist challenger, and that the outcome had been decided before I sat down. Four seconds. No trash talk, no celebration. She went back to her food the way you move on from something that was never really a question, while I sat there recalibrating my entire understanding of the week.

Five days of altitude couldn’t humble me, because I was too busy doing pushups at it.

A seven year old needed four seconds.

Komic: The Sacred Absurd

Komic claims the title of highest village in Asia connected by motorable road, sits at more than 15,000 feet, and contains one monastery, a handful of houses, and on the day we visited, six adults doing Chaiya Chaiya in front of the Buddha statue a few hundred metres from the top.

I can’t fully reconstruct how it started. Someone hummed. The hum found a second voice. And then it wasn’t humming anymore, it was the full routine, train-roof energy, shoulders and all, in front of highest buddha statue in the world.

Buddha didn’t object. I choose to believe he was deep in meditation. I also believe, with equal conviction, that he has seen worse.

There’s a version of this story where it reads as disrespect. I don’t think it was. I think when a place overwhelms you past a certain point, you respond with the most instinctive joy you own. Ours happened to be a 90s Shah Rukh number. The Buddha kept smiling. Statues do that, but still.

Kalpa Again: 27 at 9,000 Feet

Coming back through a place you’ve already seen has a different texture. Kalpa on the way in was a view. Kalpa on the way back was a verdict, the same valley asking what you did with the last five days.

The cake came out as soon as the clock hit 12.

The cake came out because someone in the room had decided the clock wouldn’t hit twelve without it. She’d found the one bakery on the way to Kalpa that half exists, convinced it to fully exist for a day, and made sure I spent the first minute of twenty-seven laughing instead of just being tired. The cake tasted like that effort — incredible, and a little structurally unsound.

The bonfire that night turned everything orange. Cold came down from the valley, the fire pushed back, and we sat inside that negotiation for hours. Around midnight I caught myself thinking: I don’t want more Spiti, exactly. I want more of this. The thing where you’re somewhere you chose, with people you chose, and there is nowhere else you’re supposed to be.

Chitkul: The River Knows

Chitkul is the last village before the Indo-Tibetan border. Past it you need permits, and past those you need a different passport. The Baspa river runs through it carrying glacier melt that is the exact colour of somewhere you haven’t been.

I did pushups on the bank. Mid-rep, my face passed close enough to the water that an opportunity presented itself, and I have very little self-control near rivers. So I dipped my face in. Snowmelt cold is not regular cold. Regular cold is a tap on the shoulder. This was a slap with paperwork. I came up instantly, reconsidered my life, and went back down for another.

Later I found a flat rock by the water and lay down on it, intending to rest for a moment. The river was exactly the right sound and the rock was exactly the right temperature, and then it was twenty minutes later and someone was taking photos of me for evidence.

The Last Sunset, and Then the Rain

The sunset on the last evening was too good. I mean that as an accusation. It felt like the mountains had checked the calendar, seen we were leaving in the morning, and decided to run up the score. The sky went through its colours in the wrong order. The valley filled with light at angles that don’t survive geometry. We took photos knowing the photos would fail, because you have to try anyway.

And in the morning, it rained.

Not a storm. Nothing dramatic. Just steady, considered drizzle, falling on roads we were about to drive out on, after five days of skies so clear they felt personal.

So there we were. Bags half-loaded. Nobody moving towards the bus.

I still don’t know if it was the valley saying goodbye or saying you left something here. I’ve turned it over a few times since. Both feel true, and neither explains why none of us could get in the bus.

We drove out of Spiti in the rain. I kept looking back, at the flags, at the roads, at all the ego I’d left at altitude, at a homestay in Kaza where a seven-year-old owns four seconds of my life. We didn’t talk much on the drive down. Not because we were tired.

Some things you don’t want to name yet.

Spiti doesn’t let you leave with all your edges intact. That’s probably the point.

In the second after you speak, your voice leaves your phone, crosses a telephony network that still speaks a protocol older than the web, lands on a server that has to decide you’re actually talking and not just breathing, gets transcribed into text, gets sent to a large language model that thinks up a reply, gets turned back into a human-sounding voice, and gets pushed back down the same line to your ear. If any one of those steps takes too long, the AI talks over you, or sits in dead silence, or answers a question you didn’t ask. All of it has to happen in under a second, every turn, on every call, forever.

Here’s the part nobody tells you: the “AI” in that chain is the easy 10%. The model is a single API call. The other 90% is plumbing. It’s the WebSocket that times out silently at 3am. It’s a recording bug where the bot’s audio packs itself tight with no silence between turns, so the saved call sounds like the AI is talking over itself. It’s an LLM that leaks <function>call_api()</function> into its output, and the voice engine reads it aloud as “less than function call api greater than.” It’s a race condition that drops the very first thing the AI says on every other call.

I spent a month building openVAPI, an open-source, self-hosted alternative to Vapi and Retell. About 30 days. Around 4,600 lines of core pipeline code. One very long 3:35 AM commit. And I wrote every line of it.

This is the engineering journal. The wins, the disasters, and what the git log actually says.

The Anatomy of That Second

Before the war stories, here’s where the second actually goes. These aren’t marketing numbers. The first row is a value I chose myself, the rest are typical figures for the providers in my stack, and later you’ll meet the TurnMetrics dataclass that stamps every one of these stages on every real turn.

Add it up and the full path from your last syllable runs somewhere between 1.2 and 1.7 seconds. The sub-second figure everyone quotes starts at row two, after the silence check. Which is fair, because that 800 ms is not the AI being slow. It’s the pipeline being polite.

Cut the silence window shorter and the bot interrupts you every time you pause to think. Leave it longer and every reply feels like a long-distance call from 1991. The single biggest lever in voice AI latency has nothing to do with the AI. It’s deciding how long a human silence has to last before it counts as a turn.

The Setup

On May 11, 2026, I committed the entire scaffold in one shot: a FastAPI backend (Python’s async web framework) with CRUD for assistants, phone numbers, and call logs. A Next.js UI with a dark theme, because I already knew what hours I’d be keeping. Postgres for durable storage, Redis for fast in-memory state, Docker to run it all. 57 files, 3,261 lines. The architecture was deliberate from day one: one process, no worker pool, no threads. Every incoming call rides on an asyncio Task. All IO is awaited. A semaphore caps concurrent calls at 50. You scale by running more pods.

Three days later, the voice pipeline landed. I built it on top of Pipecat, a Python framework for real-time voice AI from the folks at Daily. Pipecat handles the hard distributed-systems problems: moving audio around, passing it between processing stages as “frames,” and managing whose turn it is to speak. What I built on top was the production layer Pipecat doesn’t give you.

That layer is a tour of the modern voice stack. Twilio and Plivo for telephony (the actual phone carriers that own the numbers and ring the call). Deepgram for STT, speech-to-text, turning what the caller says into words on the wire. ElevenLabs for TTS, text-to-speech, turning the AI’s reply back into a voice that sounds human. OpenAI and Groq as the LLM, the brain that decides what to say. I wired them together with a plugin registry for the carriers, a service factory, a pipeline builder, event handlers with per-turn millisecond timing, and cost calculation in a pricing.toml. Four vendors, four billing models, one TOML file to keep them all honest.

One detail that trips up everyone: phone audio is bad on purpose. The telephony pipeline runs at 8kHz mulaw, a low-fidelity, narrow-band format designed in an era when bandwidth was precious. It’s why every phone call sounds slightly muffled. That commit was 69 files, 14,521 lines. The first phone call actually connected.

Around May 18, I added browser calls. For those I used WebRTC, the same peer-to-peer audio and video tech that powers Google Meet and Discord. Getting a server to speak WebRTC (browsers do it natively, servers don’t) means aiortc, the Python library that implements the protocol, wrapped here by Pipecat’s SmallWebRTCTransport. Browser audio comes in at a cleaner 16kHz instead of the phone’s 8kHz, so the same pipeline now has to juggle two sample rates depending on where the call came from. I also built a cost calculator so I’d know exactly what each call cost, down to the token and the character. On the cheapest stack (Groq for the brain, Deepgram for the ears, ElevenLabs for the voice, Twilio for the line), a 3-minute call comes out to roughly $0.10. About 8 rupees. Less than the chai you’d drink while debugging it.

1 AM, docker compose up, Again

The git log for May 20 is telling. Between 01:13 and 02:04, there are 28 commits, all in under an hour. What was I actually doing? Trying to get a single outbound phone call to connect end to end.

Telephony providers do not agree on anything. The handshake itself is a little dance: the carrier answers the call, pings your server over the internet, you hand back a set of instructions that tells it to open a live audio socket, and then it streams the call’s raw audio to you in real time. Twilio sends that audio as JSON with base64-encoded mulaw. Plivo uses a slightly different framing. A serializer has to abstract both so the rest of the pipeline just sees a uniform InputAudioRawFrame and OutputAudioRawFrame and never has to care which carrier is on the line. Getting that right took 14 attempts in 51 minutes.

That’s what those 28 commits are: each attempt left a pair of snapshots. Not a clean, beautiful git history. One person at 1 AM, running docker compose up again and again, reading logs, fixing one framing issue at a time. Every run started with the same thought, this is the one that fixes it, and run 14 finally was.

“wholesale improvements”

On May 27, I made my biggest single commit and titled it “wholesale improvements” because I genuinely couldn’t think of a better name. 47 files, 1,913 insertions, 312 deletions. Here’s what was in it:

The webhook service. When a call ends, you often need to tell some other server about it. That’s a webhook, an HTTP call your system makes outward. Mine signs every payload with HMAC-SHA256 (so the receiver can prove it really came from me) and retries on failure with exponential backoff at [0, 5, 30, 300, 1800] seconds. The last retry fires half an hour later, which in webhook time is a formal apology letter. A reconciliation loop finds unsent webhooks on startup and fires them. Every attempt is logged with status code, response body, and error.

The Vapi compatibility layer. vapi_compat.py exposes a REST shape that matches Vapi’s API exactly. Any tool already built against Vapi can point at openVAPI by changing one URL. That single decision probably removed more adoption friction than any feature I could build.

The background scheduler with crash recovery. An asyncio task that wakes every 60 seconds, dials any call that was queued for a future time, and cleans up orphans: if the server crashed mid-call, on restart it finds every call stuck in limbo, hangs it up through the carrier’s API, flushes the half-finished transcript from Redis to Postgres, and returns the phone number to the pool.

S3 storage, consolidated database migrations, and rewritten event handlers with a TurnMetrics dataclass that times every stage of every turn: when speech was detected, when the transcript finalized, when the LLM started, when its first token arrived, when it finished, when the voice started speaking, and when it stopped. Every turn, every call, in milliseconds.

That’s the thing about voice AI. The intelligence is an API call. The work is everything around it.

The Disaster Section

Four bugs. Each one cost me days. Each one taught me something no tutorial covers.

Bug 1: The recording desync (3 days)

This was the hardest bug in the whole project. It took three days just to understand. Once the math finally clicked, the fix itself landed in a 40-minute burst of commits on the evening of May 28.

The symptom: saved call recordings were broken. The system records both sides of a call, the human and the AI, then mixes them into one audio file. But the bot’s audio was packed tight with no silence between its turns. When the mixer combined the two tracks, all of the bot’s turns landed at the very start. The recording sounded like [bot1, bot2, bot3… then user1… user2], two people in a conversation where one of them lives in the past.

The root cause was subtle. The processor capturing bot audio stored raw bytes with no timestamps. The mixer had no idea when each burst of speech actually happened, so it just concatenated them. The human’s audio, meanwhile, spanned the real call timeline correctly, because its capture processor sat earlier in the pipeline and saw every frame. The bot’s audio was positionless.

The fix: store each chunk as a (wall_clock_offset, audio_bytes) pair, then rebuild the full track by dropping each burst at its real-time position, with silence filling the gaps between.

def _build_bot_track(chunks: list[tuple[float, bytes]], sample_rate: int) -> bytes:
    """Reconstruct bot audio track with silence gaps between turns preserved."""
    track = bytearray()
    write_pos = 0  # bytes
    for offset_secs, audio_bytes in chunks:
        wall_pos = int(offset_secs * sample_rate) * 2
        if wall_pos > write_pos:
            if wall_pos > len(track):
                track.extend(b"\x00" * (wall_pos - len(track)))
            write_pos = wall_pos
        end_pos = write_pos + len(audio_bytes)
        if end_pos > len(track):
            track.extend(b"\x00" * (end_pos - len(track)))
        track[write_pos:end_pos] = audio_bytes
        write_pos = end_pos
    return bytes(track)

The tricky part: within a single turn, the voice engine streams audio faster than real-time, so consecutive frames land at wall_pos < write_pos and just append in sequence. Between turns, wall_pos jumps ahead, inserting exactly the right amount of silence. Get this wrong by a few samples and the entire recording drifts out of sync. I rewrote it three times before the math held.

Two minutes after the recording fix, at 19:18, I pushed a commit titled “made pipeline complete.” 93 insertions across 9 files: the scheduler, the event handlers, the pipeline builder, the service factory, and the WebRTC pipeline all wired together and talking to each other for the first time. The quiet follow-up that made everything actually work.

Bug 2: The race condition that ate the first message

The AI’s opening line was vanishing on every other call. Half the time the bot was a stand-up comedian delivering the opener before the doors opened. Here’s why. Before the AI can speak, two things have to be true: the pipeline has to be booted and the caller has to be connected. If the pipeline boots first and queues the greeting before the caller is on the line, the audio goes nowhere. If the caller connects first, the pipeline isn’t ready yet.

ready_state = {
    "pipeline_started": False,
    "client_connected": False,
    "triggered": False,
}

async def _trigger_initial_response():
    if (
        ready_state["pipeline_started"]
        and ready_state["client_connected"]
        and not ready_state["triggered"]
    ):
        ready_state["triggered"] = True
        if first_message:
            await task.queue_frame(
                TTSSpeakFrame(first_message, append_to_context=True)
            )

Two events, one gate. Whichever fires second triggers the greeting. It looks obvious now. It took me a day to figure out why the greeting kept disappearing.

Bug 3: The XML tag leak

When an LLM uses a tool, it emits markup like <function>call_api()</function> in its output. That’s expected and correct. The problem is when those tags slip through to the voice engine, which dutifully reads them aloud: “less than function call api greater than.” On every single call that triggers a tool.

I wrote a filter that strips them before they reach TTS:

class XMLFunctionTagFilter(BaseTextFilter):
    _PATTERN = re.compile(
        r"<function[^>]*>.*?</function>",
        flags=re.DOTALL | re.IGNORECASE,
    )
    async def filter(self, text: str) -> str:
        return self._PATTERN.sub("", text)

Four lines. Zero dependencies. Saved every call from sounding like someone reading HTML out loud.

Bug 4: Deepgram’s empty final transcripts

Speech-to-text engines stream their best guess as you talk, refining it word by word. Deepgram would return a perfectly good interim guess like “Okay.” Then it would return an empty final. Pipecat only creates a transcript event for non-empty finals, so the logic that decides “the human is done talking, go reply” would stall. Voice Activity Detection said the caller stopped, but there was no transcript to act on. The pipeline just waited. Forever.

The fix lives inside a custom STT wrapper I wrote (886 lines in service_factory.py alone). When a final comes back empty but I have a cached interim, I promote the interim as the real transcript. Deepgram’s docs don’t mention this edge case anywhere. I found it by dumping per-turn WAV files and realizing the engine was hearing audio, producing a transcript, then throwing it away. A waiter who takes your order, reads it back to you, and bins it on the way to the kitchen.

The Echo Problem

When the AI speaks, its voice comes out of the caller’s speaker, bounces around the room, re-enters the microphone, and gets transcribed right back. The AI hears its own voice, treats it as the human talking, generates a reply to itself, speaks that, hears it again. An infinite loop of a robot arguing with its own echo.

The textbook fix is AEC, Acoustic Echo Cancellation: subtract the signal you’re playing from the signal you’re hearing. Done properly it has to account for room acoustics, speaker placement, and mic sensitivity, all of which change on every call. Heavy machinery.

I went a different way. Pipecat’s user aggregator already knows when the bot is speaking and broadcasts mute-start and mute-stop signals. The catch: those signals only announce the mute state, they don’t actually tell the STT engine to stop listening. So I wrote a custom EchoSuppressionMuteStrategy that acts on them inside the STT layer itself, paired with a DebouncedExternalUserTurnStartStrategy that adds a cooldown. Even if echo sneaks past and trips the voice detector, the debounce refuses to start a new turn unless a full second has passed since the last one. Two signals, one confirmation. False positives dropped by roughly 90%.

The Voicemail Detector

Indian phone networks have their own voicemail greetings, some English, some Hindi. A detector that only knows English patterns is useless for calls in India.

_PATTERNS = [
    r"please (leave|record) (a|your) message",
    r"not (available|here)",
    r"after the (beep|tone)",
    r"beep ke baad",       # Hindi: "after the beep"
    r"sandesh chhodiye",   # Hindi: "please leave a message"
]

It also has a fallback that needs no language at all: if the voice detector stays active for more than 8 seconds before the first transcript arrives, the other end is almost certainly a recorded greeting, not a person taking a breath. The bot hangs up before it starts leaving a message on someone’s answering machine.

The Empty Response Fallback

Sometimes the LLM returns absolutely nothing. No text, no tool call, no interruption. Just silence. Maybe the prompt confused it. Maybe the provider hiccuped. Maybe a server somewhere sneezed.

Without a fallback, the pipeline sits in dead air. The caller says “hello?” again. Still nothing. They hang up. You just lost a call to literally nothing.

if (not _llm_turn_text_seen["value"]
        and not _llm_turn_tool_called["value"]
        and not _llm_interrupted["value"]):
    await task.queue_frame(
        TTSSpeakFrame(
            "I'm sorry, I didn't quite get that. Could you repeat yourself?",
            append_to_context=True,
        )
    )

Three boolean checks. One apology. append_to_context=True so the LLM remembers it said this and doesn’t get confused on the next turn. This fires on roughly 3% of calls. Without it, every one of those is a silent failure.

The Webhook Race Condition

At 19:54 that same evening, I pushed the webhook dedupe fix. The race: when a call ends, the pipeline’s cleanup block fires and tries to deliver the call-ended webhook. But the scheduler’s reconciliation loop might find that same unsent webhook and try to deliver it too. Two workers, same payload, hitting the customer’s server twice. The call gets announced as ended twice, which is one more ending than most calls have.

The fix: lease-based dispatch backed by Redis. Before sending, a worker claims the dispatch with a short-lived lock. claim_webhook_dispatch() atomically checks and sets a “sent” flag. If someone else already claimed it, you skip. After delivery, mark_webhook_sent(). If all retries exhaust, mark_webhook_exhausted() so it never loops forever.

Three commits in 40 minutes on a Tuesday evening: the recording fix, the pipeline wiring, and the race condition. That’s what voice infrastructure engineering actually looks like.

The 3:35 AM Commit

On June 8, at 3:35 AM, I pushed my biggest feature drop. Realtime voice pipelines for the OpenAI and Azure OpenAI Realtime APIs, a fundamentally different design where listening, thinking, and speaking all happen inside one model over a single connection, instead of the traditional relay of STT to LLM to TTS. Lower latency, but a completely different shape, so I had to write a separate build_realtime_pipeline() because the frame graph isn’t the same.

New providers landed in the same commit: Google Vertex as another LLM option, Google TTS and STT, Sarvam STT for Indian languages, Cartesia for a faster voice. The XMLFunctionTagFilter. In-memory audio buffering with background S3 uploads (fire-and-forget tasks held by a strong reference so the garbage collector doesn’t kill an upload mid-flight). A metrics aggregator that tracks prompt tokens, completion tokens, voice characters, and processing time across every stage. And an independent max-duration watchdog as a backstop: if the pipeline somehow never ends a call, a separate task forces it after a timeout.

Then I kept going. Most people sleep after a 3 AM commit. That same day I shipped production configs (a docker-compose.prod.yml that stops exposing Redis and Postgres on the network, plus a Caddy reverse proxy) and post-call summaries (when an assistant has a summary_prompt, the transcript goes to the LLM after hang-up and the summary lands in the database). The 3 AM commit was the headline. The production configs are what turned it from a prototype into a product.

Production Hardening and the UI Revamp

June 9 was cleanup day, the kind of day where nothing demos well and everything matters. Webhook retry triggers reworked. The transcript generation got a major overhaul, 214 lines added to call_transcript.py. Provider columns changed from a strict enum to a plain string, so adding a new provider no longer requires a database migration. Bug fixes across both carriers.

On June 10 at 23:14, I pushed “complete ui revamp.” 52 files changed. 3,512 insertions, 4,229 deletions, net negative because I deleted the old component structure and rebuilt it. Best diff stat of the month. Dashboard, analytics, and settings pages. A real component library: cards, modals, toggles, status dots, empty states, page headers. Every page got its own component instead of being smeared across a dialog, a table, and an edit page. The thing finally looks like a product.

The Architecture (What Actually Runs)

Pipecat does the heavy lifting. One pipeline per call, running as an asyncio Task inside FastAPI. No workers, no threads. A semaphore caps concurrent calls at 50.

• Telephony: Twilio and Plivo via a plugin registry. Adding a carrier means three files and a registration at import time.
• STT: Deepgram, wrapped in a custom class: interim promotion, echo suppression, per-turn WAV dumps for debugging.
• LLM: OpenAI, Groq, Google Vertex, Together AI via a factory, plus the OpenAI Realtime API where listen-think-speak collapse into one service.
• TTS: ElevenLabs, OpenAI, Deepgram, Cartesia, Google, and Sarvam for Indian languages.
• WebRTC: SmallWebRTCTransport (aiortc under the hood) at 16kHz for browser calls.
• VAD: Silero, tuned to 0.3s to start and 0.8s to confirm a stop.
• Recording: dual capture processors with wall-clock offsets, mixed to mono, uploaded to S3.
• State: Redis for live call state, the transcript buffer (zero database writes while a call is active), and the phone number pool. Postgres and S3 for everything durable.
• Webhooks: HMAC-SHA256 signing, exponential backoff, Redis lease-based deduplication.
• Crash recovery: the scheduler resolves orphaned calls on startup, flushes partial transcripts, and returns numbers to the pool.

Where We Are Now

Here’s the honest status:

One caveat belongs next to that table. This is a one-person, one-month codebase: a single integration test, no CI pipeline, and nothing has pushed it past the 50-call semaphore yet. Every “Working” above means working on real calls, not battle-tested at scale. The QA department is me, my phone, and a 1 AM docker compose habit.

The Insight

Building a voice AI platform is an exercise in managing complexity at every single layer. The intelligence, the part that sounds impressive in a pitch deck, is a few API calls. The other 90% is the plumbing.

What still surprises me is that effort and impact refuse to correlate. My best code is four lines that strip XML tags from a voice stream. The bug that took the longest was a recording mixer that didn’t know what time it was. And the feature I’m proudest of is a Hindi voicemail pattern that took one line.

This is what real voice infrastructure looks like. It’s not glamorous. But it works.

The commit messages are vague but the code tells the real story.

Chip War has a name for this. Chip War’s whole thesis is that real technological progress doesn’t move in straight lines. It staggers. Long flat stretches, then a vertical jump. The history of semiconductors is mostly people failing in rooms for years, then a breakthrough that changes everything at once.

Here’s the trick: companies figured out how to take that jump and sell it back to you as a line.

Say a manufacturing breakthrough gives a 35% improvement in processor performance. They don’t ship all 35% at once. They stage it: 20% this year, 20% next. Same science. Tidier calendar. Science doesn’t have a fiscal quarter — but someone gave it one.

Hardware progress has been slowing for fifteen to twenty years — we’re at the physical limits of how small a transistor can get. The improvements announced now are mostly software. Not the same thing.

Here’s what I keep thinking about: the 18 months were the progress. The week was just when it became legible. We’ve built everything — keynotes, quarterly reports, annual reviews — around the moment something becomes visible, not the moment it becomes real. Those are different moments. Often years apart. We just don’t have a ceremony for the invisible ones.

I upgraded every time they told me to. I trusted the curve.

Nobody clapped for those eighteen months. No stage, no announcement. The actual progress happened in a room with bad lighting and probably a lot of bad coffee, and it looked, from the outside, like nothing.

Progress used to be a rupture. An event. Something that happened to the world and left it different. Now it’s a release date. And I’m not sure we can tell the difference anymore — between a thing actually changing, and being told it’s time to notice.

The breakthrough happened in the bad-lighting room. The keynote is just the ceremony.