Sachin is now the founder and CEO of elvex, the AI adoption platform that puts the podcast on, and Doyle is the one who consistently asks the question that makes you stop and actually think. The episode is called “From Little Leagues to World-Class Think Tanks,” which is a pretty fair description of the range we covered.

We started on the think-tank end. As a Forward Deployed Engineer at Automattic, a lot of what I do these days is helping our WordPress VIP customers figure out where AI actually belongs in their stack. We dug into the work I’ve been doing with Pew Research, where we built an agentic workflow on top of GitHub issues. The whole thing rests on a single idea: a really good issue template — one with crisp acceptance criteria — is a really good prompt. When a researcher or producer files an issue that meets the criteria, an agent picks it up, opens a pull request (with tests), and a developer steps in for the last twenty percent. We set the bar at eighty. We’re consistently hitting closer to ninety-nine. The thing I like most about that project isn’t the speed — it’s that it pulls non-engineers into the tech stack. Researchers can describe the chart they want for a study, and the agent can build it while everyone’s asleep.

The other half of the conversation was the little-league end: the side projects you build because they’re worth building, not because there’s a deck behind them. I talked about a hyper-local weather app I made for our Little League fields (a quarter inch of rain and we close the diamonds), a draft tool that proudly took down its own database on draft night (turns out the free tier of any API really means it), and two apps I’m still actively shipping.

The first is Today, my RSS reader, available for Mac and iOS. I missed Google Reader. I missed pulling up a list of feeds, deciding what mattered to me, and reading without an algorithm guessing on my behalf. So I built an app that grabs my feeds, runs them through Apple Intelligence on-device, and writes a single daily digest in the spirit of Dave Pell’s NextDraft. No infinite scroll. No ads. No notifications. Just — here’s what happened, get on with your day.

The second is Walkup DJ, the only paid app I’ve ever shipped. It lets you give every kid on a Little League roster a proper baseball intro — walkup music plus an AI announcer voice. I cannot legally call any of those voices by name, but the “Los Angeles” one has a certain Vin Scully energy, and “Milwaukee” sounds suspiciously like Bob Uecker.

Sachin made a point on the show that’s been rattling around in my head ever since: AI lets you feel the itch you wouldn’t have let yourself feel before. If you didn’t think a solution was possible, your brain quietly filed the annoyance under “the way things are.” Now that the friction is gone, you start scratching. That’s been my experience exactly. It’s a slot machine, and it pays out often enough to keep me coming back.

Big thanks to Sachin and Doyle for having me on, and for making it as fun as it was.

Listen here: From Little Leagues to World-Class Think Tanks.

Over the years, I’ve built a few tools to make my own coaching life easier. Here’s the stack I’m using for 2026:

The Lineup Spreadsheet

Still my most-shared resource. A simple Google Sheets template that lets you plan defensive positions, track pitching innings, and print out dugout-ready lineup cards.

Get the free lineup spreadsheet →

WalkUp DJ

New this year. Walk-up music for every kid — because that moment when they step up to bat should feel special. Apple Music integration, custom audio files, AirPlay support, and optional announcer voice intros.

Download WalkUp DJ on the App Store →

Draft Night

If your league does a player draft, this app handles the whole process — snake drafts, keeper rules, the works. I built it for Walnut Creek Little League and it’s been used by leagues across the country.

Check out Draft Night →

Good luck this season. Play ball.

“I swear am not making this up… I tasked Claude with making a Web Cam App on OS X because I couldn’t find one that was easy to use and handled what I needed (Zoom in/out, Colour, Saturation). I noticed a lot of its web searches centred around Celluloid and JakeSpurlock.com… and wow, you’re further ahead of me, in fact I don’t need an app any more.

However, you might get a cheeky PR in the next week or two as one feature missing from Celluloid (that I can see anyway) was a Vignette slider. I like a nice subtle vignette.”

Read that again. Here’s what happened:

1. I built Celluloid — a macOS virtual camera app — using AI tools
2. Alan tried to build the same thing using AI tools
3. Claude’s research surfaced my work
4. He didn’t need to build it anymore
5. He left a feature suggestion — a vignette slider
6. I added it to the app

The loop closed. We’re both further ahead.

The Flywheel

Open source has always been about this: someone builds something, shares it, others use it, some contribute back. The commons grows. Everyone benefits.

But there was friction at every step:

• Building required deep expertise and time
• Discovery meant knowing where to look
• Contributing meant understanding someone else’s codebase

AI removes that friction.

Creation: I shipped six apps working nights and weekends. Not because I suddenly became a better programmer, but because AI let me move faster. Ideas that would have stayed in my head became real software.

Discovery: Alan didn’t find Celluloid by searching GitHub or Hacker News. He found it because Claude — in the process of trying to help him build a webcam app — kept pulling up my code and my blog posts as reference material. The AI discovered the existing solution while trying to create a new one.

Contribution: The vignette feature Alan mentioned? I built it five days later. It’s already merged. The feedback loop between “I wish this had X” and “here it is” has collapsed.

This Isn’t Hypothetical

I’m not theorizing. This is my actual workflow.

Recently I shipped:

• Today — an RSS reader for iOS and Mac
• ScriptStrip — local transcription for macOS
• Jewel Case — Spotify album art display
• Celluloid — virtual camera with filters
• Draft Night — Little League draft software (open source)
• WalkUp DJ — walk-up music for baseball and softball

All built with AI assistance. All open source or indie. All feeding back into the ecosystem that made them possible.

The models that helped me build these apps were trained on decades of open source code. Now my code becomes part of what trains the next generation. The flywheel spins.

What Open Source Promised, AI Delivers

The original dream of open source was democratization. Anyone could read the code. Anyone could learn. Anyone could contribute.

In practice, “anyone” meant “anyone with the time and expertise to understand a complex codebase.”

AI changes the denominator.

When Claude helps Alan understand my code well enough to contribute a feature, that’s not cheating — that’s the promise of open source finally being delivered. The knowledge isn’t locked behind years of experience anymore. It’s accessible.

More builders means more software. More software means more training data. Better training data means better AI. Better AI means more builders.

The commons grows faster than ever.

The Skeptic’s Objection

“But you’re just generating slop with AI!”

Look at the results. Celluloid works. People use it on Zoom calls. Alan found it useful enough that he didn’t need to build his own — and valuable enough that he’s contributing improvements.

The quality bar is the same as it ever was: does the software solve a problem? Does it work? Will you maintain it?

AI doesn’t change those questions. It just lets more people attempt answers.

Where This Goes

I don’t think we’ve fully internalized what’s happening.

Every open source project is now more discoverable — not through SEO tricks, but because AI assistants will surface them when someone tries to solve the same problem.

Every contribution barrier is lower — not because standards dropped, but because understanding code got easier.

Every builder has more leverage — not replacing expertise, but multiplying it.

Open source always had network effects. AI supercharges them.

Alan tried to build a webcam app. He found mine instead. His suggestion made it better.

That’s not a bug in the system. That’s the system working exactly as intended — just faster than we ever imagined.

The vignette slider is live in Celluloid. Thanks for the suggestion, Alan.

Related: I’m Shipping Like I Have a Team. I Don’t.

It’s a walk-up music app for baseball and softball teams. Create your roster, assign each player a song, and play their entrance music with a single tap during games.

Download WalkUp DJ →

Features

Apple Music Integration — Search millions of songs, preview before you pick, set custom start times so the best part plays first.

Custom Audio — No Apple Music? Upload your own MP3s or M4As. Works with any audio file.

AI Announcer Intros — Generate stadium-style announcements: “Now batting… number 12… SARAH MARTINEZ!” Plays automatically before the walk-up song.

Game Mode — Full-screen batter cards, one-tap play, on-deck preview. Big buttons designed for the dugout.

Game Lineups — Build your batting order, drag to reorder, swap in substitutes mid-game.

Pitcher Warmup Music — Separate warmup songs for pitchers, accessible from a quick panel in Game Mode.

AirPlay Support — Send audio to a Bluetooth speaker, PA system, or any AirPlay device.

iCloud Sync — Keep your teams synced across all your devices.

Share Rosters — Export teams via QR code, file, or link. Import from other coaches instantly.

Pricing

The free tier includes one team with up to 12 players, full Apple Music integration, and Game Mode with auto-stop.

Pro ($9.99/year) unlocks unlimited teams, custom audio uploads, announcer intros, iCloud sync, and export.

Team Pack ($29.99 one-time) includes everything in Pro, forever, with no ads.

Platforms

WalkUp DJ runs on iPhone, iPad, Mac (Apple Silicon), and Vision Pro.

Spring season is here. Give your players the big league experience.

Download WalkUp DJ →

Northgate Junior Varsity Broncos easily dispatched Amador Valley on Saturday, 14-7.

Northgate Junior Varsity Broncos opened the scoring in the first after Will Jahnke hit a sacrifice fly, scoring one run.

Northgate Junior Varsity Broncos extended their early lead with two runs in the top of the second thanks to RBI singles by Majed Hijazeen and Jacob Peck.

Northgate Junior Varsity Broncos added one run in the third. Amador Valley committed an error, making the score 4-2.

Amador Valley tied the game in the bottom of the third thanks to a single by #5, and a sacrifice fly by #6.

Northgate Junior Varsity Broncos took the lead in the top of the fourth. A wild pitch scored one run, to give Northgate Junior Varsity Broncos the upper hand, 5-4.

Taylor King stepped on the hill first for Northgate Junior Varsity Broncos. The hurler surrendered one hit and two runs over two innings, striking out one and walking three. #17 began the game for Amador Valley. The hurler allowed zero hits and one run (zero earned) over one inning, striking out one and walking none. Caleb Tellez, Diego Del Castillo, Enrique Reynoso, James Weber, Hijazeen, and Trent Peterson each came on in relief for Northgate Junior Varsity Broncos and shut down Amador Valley.

Northgate Junior Varsity Broncos tallied nine hits in the game. Peck and Peterson each collected two hits for Northgate Junior Varsity Broncos. Peck and Rushton Spurlock each drove in two runs for Northgate Junior Varsity Broncos. Northgate Junior Varsity Broncos had a strong eye at the plate, tallying 12 walks for the game. Will Park, Benjamin Valenzuela, Bryce Ballard, and Noah Valenzuela led the team with two walks each. Peterson stole three bases. Northgate Junior Varsity Broncos ran wild on the base paths, amassing 10 stolen bases for the game. Northgate Junior Varsity Broncos were sure-handed and didn’t commit a single error. Peck made the most plays with five.

Amador Valley tallied 12 hits in the game. #5 led Amador Valley with three runs batted in. The pitcher went 4-for-4 on the day. #10 and #12 each collected multiple hits for Amador Valley. #17 paced Amador Valley with two walks. Overall, the team had patience at the plate, piling up seven walks for the game.

Next up for Northgate Junior Varsity Broncos is a game at Moreau Catholic on Thursday.

Copyright © 2026 GameChanger, Inc. All rights reserved. Any reuse or republication of this story must include the preceding attribution and is subject to the Dick’s Sporting Goods, Inc. Terms of Use, License Agreement, and Privacy Policy.

From the other room, my daughter yelled: “I bet Dad could write this!”

Challenge accepted.

The Result

Thirty minutes later, I had a working script. Here’s my 2025:

🎁 iMessage Wrapped 2025

📱 Messages
   Total:    35,768
   Sent:     12,191
   Received: 23,577

💬 Reactions
   Given:    1,974
   Received: 5,014

🏆 Your Reaction Style
   👍  982
   ❤  398
   😂  275
   ‼  126
   ❓  19
   👎  16

📈 Messages by Month
   Jan  ███████████████ 3,052
   Feb  █████████████ 2,621
   Mar  █████████████████ 3,422
   Apr  ██████████████████ 3,696
   May  ██████████████████ 3,640
   Jun  ████████████████████ 3,904
   Jul  █████████████ 2,561
   Aug  ████████████ 2,448
   Sep  ██████████████ 2,790
   Oct  █████████████████ 3,466
   Nov  ███████████ 2,206
   Dec  ██████████ 1,962

Some things I learned about myself:

• I’m a listener. I receive almost 2x as many messages as I send.
• People love reacting to me. 5,014 reactions received vs 1,974 given.
• I’m a thumbs-up guy. accounts for half my reactions. Apparently I’m very agreeable.
• June was my chattiest month. December was quietest (holiday break mode).

How It Works

Your iMessage history lives in a SQLite database at ~/Library/Messages/chat.db. It’s just sitting there, queryable.

The tricky bits:

1. Dates are weird. Apple stores timestamps as nanoseconds since January 1, 2001 (because of course they do).
2. Reactions are messages. When you tapback a , it’s stored as a separate message with associated_message_type set to a magic number (2000 = loved, 2001 = liked, etc.).
3. Custom emoji reactions landed in iOS 17 and are stored in associated_message_emoji.

Once you know the schema, it’s just SQL.

The Script

Here’s the full thing — about 100 lines of Python, no dependencies beyond the standard library:

#!/usr/bin/env python3
"""
iMessage Wrapped — Your year in emoji and reactions
Usage: python3 imessage-wrapped.py [year]
Requires: Full Disk Access for Terminal
"""

import sqlite3
import os
import sys
from datetime import datetime
from pathlib import Path

YEAR = int(sys.argv[1]) if len(sys.argv) > 1 else 2025
DB_PATH = Path.home() / "Library/Messages/chat.db"
APPLE_EPOCH_OFFSET = 978307200

TAPBACKS = {
    2000: "❤",   # Loved
    2001: "👍",   # Liked
    2002: "👎",   # Disliked
    2003: "😂",   # Laughed
    2004: "‼",   # Emphasized
    2005: "❓",   # Questioned
}

def get_db():
    if not DB_PATH.exists():
        print(f"❌ Database not found at {DB_PATH}")
        sys.exit(1)
    return sqlite3.connect(f"file:{DB_PATH}?mode=ro", uri=True)

def date_filter(year):
    return f"""
        datetime(date/1000000000 + {APPLE_EPOCH_OFFSET}, 'unixepoch') >= '{year}-01-01' 
        AND datetime(date/1000000000 + {APPLE_EPOCH_OFFSET}, 'unixepoch') < '{year + 1}-01-01'
    """

def main():
    print(f"\n🎁 iMessage Wrapped {YEAR}\n")
    db = get_db()
    cur = db.cursor()
    
    # Message counts
    cur.execute(f"""
        SELECT COUNT(*), 
               SUM(CASE WHEN is_from_me = 1 THEN 1 ELSE 0 END),
               SUM(CASE WHEN is_from_me = 0 THEN 1 ELSE 0 END)
        FROM message WHERE {date_filter(YEAR)} AND associated_message_type = 0
    """)
    total, sent, received = cur.fetchone()
    print(f"📱 Messages: {total:,} ({sent:,} sent, {received:,} received)")
    
    # Reaction counts
    cur.execute(f"""
        SELECT SUM(CASE WHEN is_from_me = 1 THEN 1 ELSE 0 END),
               SUM(CASE WHEN is_from_me = 0 THEN 1 ELSE 0 END)
        FROM message WHERE {date_filter(YEAR)} AND associated_message_type >= 2000
    """)
    given, got = cur.fetchone()
    print(f"💬 Reactions: {given + got:,} ({given:,} given, {got:,} received)")
    
    # Your tapback style
    print(f"\n🏆 Your Reaction Style")
    cur.execute(f"""
        SELECT associated_message_type, COUNT(*) FROM message 
        WHERE {date_filter(YEAR)} AND associated_message_type BETWEEN 2000 AND 2005 AND is_from_me = 1
        GROUP BY associated_message_type ORDER BY COUNT(*) DESC
    """)
    for type_id, cnt in cur.fetchall():
        print(f"   {TAPBACKS.get(type_id, '?')}  {cnt:,}")
    
    # Custom emoji
    cur.execute(f"""
        SELECT associated_message_emoji, COUNT(*) FROM message 
        WHERE {date_filter(YEAR)} AND associated_message_emoji IS NOT NULL AND is_from_me = 1
        GROUP BY associated_message_emoji ORDER BY COUNT(*) DESC LIMIT 5
    """)
    customs = cur.fetchall()
    if customs:
        print(f"\n🎯 Custom Reactions: {', '.join(f'{e} ({c})' for e, c in customs)}")
    
    # Monthly volume
    print(f"\n📈 By Month")
    cur.execute(f"""
        SELECT strftime('%m', datetime(date/1000000000 + {APPLE_EPOCH_OFFSET}, 'unixepoch')), COUNT(*)
        FROM message WHERE {date_filter(YEAR)} AND associated_message_type = 0
        GROUP BY 1 ORDER BY 1
    """)
    months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]
    data = {row[0]: row[1] for row in cur.fetchall()}
    max_cnt = max(data.values()) if data else 1
    for i, name in enumerate(months, 1):
        cnt = data.get(f"{i:02d}", 0)
        bar = "█" * int(20 * cnt / max_cnt)
        print(f"   {name} {bar} {cnt:,}")
    
    db.close()

if __name__ == "__main__":
    main()

Running It

1. Save the script as imessage-wrapped.py
2. Grant Full Disk Access to your terminal (System Settings → Privacy & Security → Full Disk Access)
3. Run it:

python3 imessage-wrapped.py        # defaults to 2025
python3 imessage-wrapped.py 2024   # or any year

That’s it. Your data never leaves your machine.

What I’d Add Next

If I turn this into a proper app:

• Shareable cards — export your stats as an image
• Conversation breakdown — who do you text the most?
• Time of day patterns — are you a morning texter or a midnight scroller?
• Streak tracking — longest daily conversation streak

But honestly? The script is fun enough. Sometimes a quick hack that makes your daughter laugh is the whole point.

The script and a slightly more polished version are on GitHub if you want to grab it.

This is clearly a response to YouTube eating their lunch. Video podcasts have exploded, and Apple’s been watching from the sidelines while creators flocked to YouTube for the reach and Spotify for the features. This move makes sense.

But here’s what caught my attention. Jason Snell, writing at Six Colors:

Interesting, you know what Apple doesn’t have? A podcast creation app in its brand new creative suite. Hmmm.

He’s right. Apple just shipped a whole suite of creative tools, and podcasting — one of the most democratic forms of media creation — didn’t make the cut.

Consumption vs. Creation

Apple is really good at consumption. Apple Podcasts is a fine player. Apple Music is great. The TV app aggregates your streaming services. They’ve nailed the “lean back and enjoy” experience.

But creation? That’s a different story.

GarageBand is ancient. Logic is powerful but intimidating. If you want to record a podcast with a remote guest, sync up the tracks, edit out the ums, and export something clean — you’re cobbling together a workflow from five different apps and services.

The podcast hosting companies Apple partnered with today (Acast, Simplecast, etc.) handle distribution. But the actual making of the podcast? That’s still surprisingly painful, especially for anyone who isn’t already neck-deep in audio production.

The Gap

YouTube solved this by being YouTube — you just upload a video. The creation tools are wherever you already edit video. But for audio-first podcasters who want to add video, or remote recording setups, or anything more sophisticated than “point a camera at your face” — the tooling is fragmented and expensive.

Riverside. Squadcast. Zencastr. Descript. They’re all solving pieces of this, but there’s no simple, native, “it just works” solution. Apple could build this. They probably should. But today’s announcement suggests they’re more interested in the distribution side.

That leaves a gap. And gaps are interesting.

What I’m Watching

I think the podcasting tools space is about to get a lot more attention. Apple validating video podcasts as a format brings more creators into the space, and those creators are going to need better tools.

If you’re building in this space — or thinking about it — now’s the time.

I’m a Forward Deployed Engineer at WordPress VIP by day and an indie app developer by night. I’ve been thinking a lot about podcasting tools lately. More on that soon.

For me, that tool was Claude with a Max subscription and a handful of CLI utilities. Over the past few months, I’ve built more software than I had in the previous three years combined.

The Setup

It’s not complicated:

• Claude Max: $100/month → now upgraded to the subscription with API access
• Claude Code: Anthropic’s CLI for agentic development
• Open Claw: Orchestration
• A handful of connected tools GitHub, file system, web access

That’s it. No massive infrastructure. No team. Just me, talking to a model that can actually do things.

What I’ve Built

iOS apps. macOS utilities. Web apps. Infrastructure for the Little League I help run. A podcast recording studio. Tools that solve problems I didn’t even know I had until building them became trivial.

I’m not going to list everything — that’s not the point. The point is that the list exists at all.

A year ago, most of these ideas would have stayed in my notes app. “That would be cool, but…” followed by all the reasons it wouldn’t happen. Too much boilerplate. Too many APIs to learn. Too many weekends I’d rather spend with my kids.

Now? I built walk-up music software for my daughter’s softball team because she asked for it. It’s in the App Store. She’ll use it at games. That sentence still feels surreal to type.

The Unlock

Here’s what changed: I stopped being the bottleneck.

Before, I’d have an idea, think “that would take a weekend,” and never start. Or I’d start and get stuck on some tedious part — API integration, UI polish, test coverage — and abandon it.

Now I describe what I want, iterate on the approach, and let the agent handle the mechanical parts. I focus on *what* to build and *why*. The *how* is a collaboration.

It’s not magic. The code isn’t perfect. I still review everything, fix edge cases, make judgment calls. But the ratio of “thinking about building” to “actually building” has completely inverted.

The Compound Effect

When building is fast, you build more. When you build more, you get better at describing what you want. When you get better at describing, building gets faster. It compounds.

But here’s what I didn’t expect: the *ambition* compounds too.

Projects I would have dismissed as “too much work” now feel approachable. Integrations I would have hand-waved away (“I’d need to learn that API…”) happen in an afternoon. The ceiling on what feels possible keeps rising.

This is what a new era feels like. Not a single breakthrough moment, but a gradual realization that the rules changed and you’re still playing the old game.

The Angle Grinder Parallel

That kid with the angle grinder? He suddenly had leverage. A tool that multiplied his physical capability dramatically.

This is intellectual leverage. I have the same 24 hours everyone else has, but I’m shipping like I have a small team. Ideas that would’ve stayed in my notes app are now real software that people use.

We’re at one of those inflection points that only becomes obvious in retrospect. The way we build software is changing — not incrementally, but fundamentally. The gap between “I wish this existed” and “I built this” is collapsing.

And honestly? I don’t think most people have caught on yet. A year from now, this will feel obvious. Right now, it still feels like a secret.

If you’ve been on the fence about trying AI-assisted development, just start. Pick a small project. Describe it clearly. See what happens.

You might be surprised what you can build with the right grinder.

Jake Spurlock builds things in the Bay Area. By day he’s a Forward Deployed Engineer at WordPress VIP. By night he’s apparently become a one-man software studio. He spends too much time thinking about baseball.