Sunday Brunch and Tailcat
How I shipped months of work between brunch and dinner, and why nobody is going to pay me for it.
On Sunday I sat down with a coffee at around 10 AM. By 7 PM, a brand-new Flutter and Dart library was live on pub.dev, and two Android phones on my desk were talking to each other directly. No server. No account. No port forwarding.
Okay, it was a long brunch. But stay with me.
First, what is Tailcat?
Tailcat is a small open-source project from the folks at Tailscale. It does one thing really well: it connects two devices with a private, encrypted line.
One side starts up and gets an address. You hand that address to the other side however you like: a QR code, a chat message, a config file. The other side connects. Done.
Behind the scenes it handles the hard parts. It starts out through Tailscale's relays, then finds a way through home routers and firewalls so your data can go straight from one device to the other. Everything is encrypted end to end with WireGuard, so the relays can't read a thing. You don't need a Tailscale account, a server of your own, or admin rights on the device.
What I built is libtailcat: Tailcat for Dart and Flutter. The nice part is that you get plain old Dart sockets back, so your existing networking code, HTTP servers and WebSockets work over the tunnel unchanged.
// Phone A
final server = await TailcatServer.start(const TailcatServerConfig());
final listener = await server.listen(port: 8080);
showQrCode(server.address.reveal());
// Phone B
final client = TailcatClient(
TailcatClientConfig(address: TailcatAddress(scannedText)),
);
final socket = await client.connect(port: 8080);
That's the whole handshake.
The possibilities are (almost) unlimited
Once two devices can talk directly and privately, a lot of ideas suddenly become cheap to build:
- File sharing between phones, laptops and desktops, straight from one to the other, without uploading to anyone's cloud first.
- Messaging where your messages never sit on a server, because there isn't one.
- Parents helping kids. See and control your child's tablet from your phone: fix a setting, approve an app, help with homework from the next room or the next city.
- AI agents talking to other agents. We're heading into a world where my agent negotiates with your agent. Do they really need a server in the middle, reading every word? Give them a direct, encrypted line instead.
- Anything security-sensitive. If you'd rather not trust a middleman with your data, don't have one.
The list stops where your imagination does.
What one Sunday produced
By the evening, all of this was done and published:
- The library, for macOS, Linux, Windows, Android and iOS. About 5,000 lines of Dart.
- About 3,000 lines of tests, run on macOS, Linux and Windows on every push.
- Prebuilt native binaries for 11 platform targets, checksummed and downloaded automatically, so nobody has to install Go to use it.
- A release pipeline that builds all of those binaries in the cloud.
- Tin Can, a Flutter example app. Pair two phones with a QR code and a string appears between them. You see the other person's fingertip glowing on your screen, feel a thud when your fingers meet, and can talk while holding your can. While the traffic goes through a relay, the string bends over a peg labelled with the relay's city. When the connection goes direct, it snaps straight with a twang.
- A demo video of Tin Can on two real phones.
- Version 1.0.0 on pub.dev.
My favorite part is how the work splits. I write the spec: what it should do, how it should feel, what "done" means. The AI writes the code, and the tests to go with it. At this scale there's no way I can test everything by hand in a day. But with a test guarding every important piece, I know I'm covered. That's real peace of mind.
And the tests earned their keep on day one. They caught a bug that only happened on Windows, a platform I wasn't testing by hand at all. It turns out the Windows clock moves in small jumps of up to about 15 milliseconds. That was just enough to make the library think a connection had ended when it hadn't. A bug like that can quietly ship and eat a week of someone's life later. This one was caught, explained and fixed the same evening.
What would this have taken the old way?
Fair warning: any estimate like this is a guess, and every senior engineer reading this will have their own. So here's mine with the working shown. Feel free to plug in your own numbers.
To be fair up front: the really hard networking (the encryption, getting through routers, the relays) is Tailscale's work. What I built is the bridge to Dart and Flutter, plus everything around it. For one experienced engineer who already knows Flutter, native code and networking, I'd put that at:
- 4 weeks: designing the API and safely wrapping Tailcat's C library in Dart
- 3 weeks: making it behave like real Dart sockets, so HTTP, WebSockets and UDP just work
- 3 weeks: build setup, compiling Go for 11 targets (Android and iOS included), plus checksummed downloads
- 2 weeks: tests
- 1.5 weeks: CI and the release pipeline
- 5 weeks: Tin Can, with QR pairing, safety codes, live touch, voice, haptics and an inspector screen
- 1.5 weeks: docs, polish, publishing and cross-platform bug hunts (hello, Windows)
Total: 20 weeks.
That's about 800 hours. At typical senior contract rates of $100 to $200 an hour, it comes to roughly $80,000 to $160,000.
Think I'm off? Maybe you're faster, or you'd skip the example app. Halve every number in that list if you like. It's still ten weeks of focused work, not one Sunday. That gap is the point, not the exact dollar amount.
And if you're wondering whether the code is any good, it's all public, tests included. Have a look.
I did it on a Sunday.
Code is a commodity now
Here's the part I keep thinking about.
I didn't type most of this code. Claude Code did. My job on Sunday was different. I wrote the specs. I decided what the library should be called and how the API should feel. I set the bar: clean, modular code, short comments, tests on every push. I decided what was ready to call 1.0.0. I paired two real phones on my desk, waved my fingers at them, and filmed it.
Writing code used to be the expensive part of building software. It isn't anymore. Code has become a commodity, like electricity: flip the switch and there it is.
What's still expensive is knowing what to build, knowing why it matters, and spotting when something is quietly wrong. Your thoughts are the limitation now. Not your typing speed, not your hours, not the size of your team. If you can picture it clearly and judge it fairly, you can probably ship it.
Most developers I know have a notes app full of ideas they never had time for. Mine just got one item shorter.
So, is software engineering dead?
I'm still figuring that out.
Some days it feels like the job is disappearing. Other days, like this Sunday, it feels like someone strapped a jet engine to it. We didn't just go fast. We went to ludicrous speed.
Where I've landed for now: people who know what good software looks like aren't being replaced. They're being multiplied. Someone still has to notice the red build on a Windows machine, care about it, and refuse to ship around it. Someone still has to say "this isn't ready yet." Someone has to own the result.
The business model (there isn't one)
Let's talk economics.
I did months' worth of work, then gave it away the same evening. It's BSD-licensed and free on pub.dev for anyone to use.
Projected revenue: $0.00, plus a handful of GitHub stars, at least one of which will be mine. Somewhere, an MBA just felt a chill.
Nobody is going to pay me for this library. If you'd like to support the project anyway, I accept payment in compliments, bug reports and very good coffee.
What's next: prchd.app
This isn't going on a shelf. prchd.app already runs on Tailscale, and I'm planning to bring libtailcat into it too. Tailcat is the lighter sibling: two devices, one address, no account and no network to set up. More on that soon.
One Sunday. Imagine a week.
If one Sunday, a coffee and a clear idea can turn into months' worth of work, I keep wondering what a full week on the right problem, with the right people, could do.
I'm genuinely excited to find out.
If you're building something where devices, people or AI agents need to talk to each other directly, or you just want to compare notes on building at this speed, I'd love to hear from you. My inbox is open.
- libtailcat on pub.dev: pub.dev/packages/libtailcat
- Source on GitHub: github.com/velzosoft/libtailcat
- Tin Can demo video: watch it above