The App He Built on His Walk Home

He Had an Idea

Marcus is fifteen. On the walk home from school, he had an idea.

His friend group was slacking. Skipping workouts. Not helping at home. Too much sitting around. He wanted to do something about it — make it a game, put up a leaderboard, give it some stakes.

He described what he wanted to his phone.

Something that combined gym check-ins, chore completions, and outdoor activity — verified by where people actually were, not just their word for it. Points for consistency. Friendly competition. An invite his five friends could accept or ignore.

His phone told him the app was ready. An hour later, his friends got the invite.

Nobody wrote code. No server went up. No database was provisioned.

What Was Already There

Marcus’s gym runs a KERI ecosystem app. Every check-in produces a signed credential — an ACDC issued to his identifier. It records what he did and when. It belongs to him.

His family uses a chore app built on the same foundation. Completed tasks are signed and stored with the person who completed them. Again — his record, not the app’s.

And somewhere running quietly, a KERI app on his phone — a cryptographic presence attestation service — records where he was and when. Not to share it. Not to sell it. Just to let him prove it later, to anyone, on demand, with his consent. The attestations stay on the device. The app issues signed credentials to his identifier, same as the gym app and the chore app do.

These three apps don’t share a database. They don’t know each other exists. They’re independent services that all happen to speak the same contract language.

When Marcus described his idea, the AI on his phone didn’t build a new application from scratch. It composed a view — a reading across the credentials he already holds — and wrapped that in a challenge structure his friends could opt into. Each friend who accepted granted consent for specific attestations, scoped to the challenge, visible to the group.

That was the whole app.

Contract-First Development

Here’s what made this possible, and why it didn’t require a developer.

In the world we live in today, data integration is hard because every app owns its own data in its own format. To stitch together gym data, chore data, and location data, you’d need API agreements with three separate companies, custom middleware to normalize the schemas, a backend to store the combined results, and users willing to hand over account access to all three.

Nobody builds that for a friend group. The friction is the point — it’s how platforms consolidate.

In a KERI ecosystem, the contract comes first. The ACDC schema defines what a gym check-in looks like before any gym app is built. What a chore completion looks like. What a location attestation looks like. The structure is public, standardized, and machine-readable.

That means any AI that understands the schemas can compose queries across them. It doesn’t need to write integration code. The integration was specified when the contracts were defined, not when the app was assembled. Marcus’s AI didn’t do something clever. It did something mechanical: find credentials matching these schemas, compose them according to these rules, produce a challenge structure.

This is what The Last Application called AID + ACDC + LLM. An identity, a set of contracts, and an intelligence that understands both. Marcus proved the formula works for a fifteen-year-old with an idea.

Nobody Gave Anyone Their Data

The part that gets buried: Marcus’s friends didn’t hand him anything.

In today’s version of this, everyone would have to install an app, create accounts, connect Strava and Apple Health, grant permissions to a central server, and trust that the server behind it won’t outlast the friendship.

Nobody does that. The ask is too large.

In the KERI model, Marcus’s friends didn’t sign up for anything. They already had identifiers. They already had credentials from their own gym apps, their own family chore apps, their own presence attestation apps running on their own phones. The composed challenge — assembled by Marcus’s AI, running at the edge, not on any central server — read only what they explicitly consented to share. Not because of a privacy policy, but because that’s how ACDCs work. Selective disclosure isn’t a feature. It’s the structure.

This is Data at the Edge taken to its logical end. The gym doesn’t know Marcus accepted a challenge. The chore app doesn’t know his friends exist. Each presence app on each phone doesn’t know any of them are connected. Each service sees only what it issued. The composition happens at the edge, in the moment, under consent.

When the challenge ends, nothing lingers. There’s no company holding everyone’s fitness records. No database to breach. The credentials go back to being what they always were: personal records belonging to the people they’re about.

Who Gets to Build Now

The obvious reading is that AI made development easier. That’s true but shallow.

The deeper reading: the kinds of applications that become possible expand dramatically when data lives with the person instead of the service.

Today, software is built around data capture. Get users in, accumulate their activity, build the lock-in. The app is the database. That model requires developers, infrastructure, and a business reason to sustain the server.

When the data doesn’t need to be captured — when it already exists, signed and held by the people it belongs to — the application doesn’t need to survive. It can be temporary. Assembled for a purpose, dissolved when done. No Migration Required explored this from the developer’s perspective. Marcus’s challenge is the same insight from the other direction: when the data follows the person, you don’t need an app that outlasts the reason you made it.

This changes who can build. Marcus didn’t need to understand software. He needed to have an idea and be in an ecosystem where the right contracts already existed under his feet.

That’s what The Kids Are Not Alright with Your Internet was pointing toward, even if nobody had the words for it. They want tools that work for them, controlled by them, that don’t accumulate their data and sell it back. They want Follow People, Not Platforms. They want to invite their actual friends, not perform for an algorithm’s graph.

Marcus built exactly that. Without meaning to, he described what contract-first development is actually for.

Conclusion

The gym app, the chore app, the presence app on each person’s phone — three independent applications. No shared infrastructure. No mutual agreement. Just three services speaking the same contract language.

On top of that foundation, a teenager with an idea can build what a development team couldn’t five years ago — not because AI wrote better code, but because the contracts were already there, waiting to be composed.

The code was never the hard part. The hard part was always the question underneath it: whose data is this, and who gets to decide what it’s used for?

When the answer is “the person it belongs to,” everything else gets easier.