← Blog

Who Looks After an AI-Built App?

AI tools now build an app for a team and run it too. Cursor joined them on November 5. Some of these tools put an owner’s name on each app. Someone still has to look after it.

When I review a batch of changes to this site, an agent builds me a page. I mark each item on the page, and the page saves my marks. Once the changes go in, I have no reason to open it again.

On November 5, Cursor launched Apps. The feature turns a page like mine into an app that a whole team can keep using. Cursor’s agents build the app. Cursor then runs it for you, with a database if the app needs one. Lovable, Bolt, Replit and OpenAI’s Sites already build and run apps like this. In its post, Cursor says most apps and tools that people build “never make it off of localhost.” Localhost is the computer they were built on.

Some of these tools now put an owner’s name on each app. When the maker moves on, the name can pass to someone else. That person may not notice when the app stops fitting the team’s work.

The tools chose to run everything for you

An app for one person now costs less to build than the annoyance it fixes. I wrote about this in Audience of One. A team app needs more than code, though. It has to be online. It needs a place to keep its data. People need a way to sign in.

Maggie Appleton made this point in a 2024 talk, “Home-Cooked Software and Barefoot Developers.” She said language models could already write the pieces of an app. But the people she was talking about still had no idea how to put one online.

Andrej Karpathy ran into the same problem in April 2025. He was building MenuGen, a small app that turns a photo of a menu into pictures of the dishes. The first version on his own computer came together quickly. He felt 80 percent done, but he was closer to 20 percent. Most of the remaining work was connecting outside services.

Appleton and Karpathy wanted different fixes. Appleton wanted the data to stay on people’s own devices. She also wanted the people who made an app to decide when it shuts down. Karpathy wanted one platform with everything already connected.

The tools built Karpathy’s version. Lovable shows how. At first, it asked users to connect their own database. In September 2025, it started to host the database and sign-in itself. I think this has a cost. Now the team depends on that one tool for its data and its sign-in.

Company accounts decide who can open an app

In 2004, Clay Shirky wrote about situated software. He meant software made for one particular group. His students at NYU built apps for their own program. The program had about 200 people on one floor. Their apps could skip identity and reputation systems. As Shirky put it, the users knew the programmers.

The new tools can use company accounts instead. In Cursor, a team’s apps open only for members of the company’s Cursor team. Public links stay off unless an admin turns them on. OpenAI’s Sites and Lovable can also limit an app to a company’s accounts. In a large company, that can be a lot of people. Many of them have never met the person who built the app. When it breaks, they may not know whom to ask.

Only some tools can hand an app on

Companies have faced the question of who owns an app before. Microsoft has let employees build their own apps on its Power Platform for about a decade. In 2019, Microsoft released a kit for company admins. The kit listed every app and who made it. By early 2020, the kit could also hand an app to a new owner.

The new tools differ on that second part. OpenAI’s Sites gives each site one owner. That owner can transfer the site to someone else. OpenAI’s guide for companies also tells them to plan the handoff.

Lovable handles it another way. When an owner leaves a Lovable workspace on their own, their projects go to the member with the highest role. If an admin removes them, the admin picks who gets the projects. Cursor gives admins a list of every app on the team. But its docs describe no way to hand an app to someone else.

Team apps stop being throwaway

All of this would matter less if these apps were thrown away after use. That is how vibe coding was first described. Karpathy coined the term. It means building an app by asking a model without reading the code. His first post about it called it “not too bad for throwaway weekend projects.” Amy J. Ko and colleagues saw something different in a 2011 survey of end-user programming. They noted that code its authors call “throw away” often becomes “quite long-lived.”

My review pages stay throwaway because only I keep anything in them. Once colleagues keep their data in a team app, nobody wants to throw it away. So the app often outlasts the person who made it.

At work, the owner of an internal tool left. People took the tool apart. They moved what it did into systems that already had someone looking after them. I read that as the team’s own answer to the ownership question.

Taking an app apart like that only works if you can get its records out. That depends on the tool. Take Google’s App Maker, a tool for internal apps. When Google shut it down, customers kept their data. The data was stored in their own databases. They only lost the apps.

Lovable works differently. It marks a project as abandoned after 60 days without use. If an admin turns on auto-delete, Lovable deletes the project after a grace period. Cursor keeps an app’s code in a repository that the team can copy. But its docs give no way to export the app’s data. They also say Cursor may remove apps “for business, financial, or legal reasons.”

So on Cursor, a team can lose its records. While an app is still running, a team member could try asking an agent to export the data. That only helps if someone thinks of it before the app is gone.

Who could look after an app

Lovable listed its tools for app owners in July. That was about ten months after it began hosting its users’ databases. I expect Cursor and the rest to add owner tools within a year. But when a tool picks the owner by role, that person may never have used the app.

The agent that built the app could look after it too. The agent can fix the code. But it cannot easily tell when the app stops matching how the team works. Say the team moves one step of its work to another tool. Then people stop filling in a field in the app. The agent sees an empty field. It could look for the reason in the team’s chat. But it has to find the right conversation, and the decision may never have been written down. For now, a person has to notice this. As agents read more of a team’s context, I expect them to take over more of this job.

A 1992 study, “Gardeners and Gurus,” looked at this need in an older setting. Michelle Gantt and Bonnie Nardi wrote it. They studied people who extended their design software. In each group, at least one person became the local developer. That person wrote the extensions and helped everyone else. The paper calls this person “a fellow domain expert.” One company called these people gardeners. The paper judged the arrangement a success where companies recognized the role. In the part-time version, the person kept their regular work. The paper also warned that full-time gardeners could “lose touch with the domain side.”

So looking after an app takes someone who still does the work. That person also needs a few hours set aside to keep the app fitting the team. A tool can put that person’s name on the app. But most companies will take longer to give that person the hours.