Without a local development environment,
can you actually finish a product?
Where fully cloud-based AI development stands today
Lately I’ve been doing some of my personal projects almost entirely from my phone.
I’m not writing code on the phone. If anything, I’ve barely written any of the code myself.
I give instructions to an AI agent from my phone, it implements in the cloud, I check the result, and I ask for fixes if I need them.
Not just editing code. Running it, debugging, getting it onto GitHub — I push as much of that as I can onto the cloud side.
I didn’t start this as an experiment in the future of development.
I simply couldn’t open a PC.
I’m on parental leave, and a lot of the day is spent holding a baby.
Using a PC with both hands is hard, and sitting down at a desk for a stretch of time is hard too.
I’m not developing instead of doing the job of parental leave.
Inside the physical constraints of leave, as a hobby kept apart from work, I just wanted to make something.
I poked at that constraint for a while, and before I noticed it had become a style: finish a product with no local development environment, using only AI agents in the cloud.
This post is notes from actually making a few products with Google AI Studio, Claude Code on the web, Cursor Cloud Agents, ChatGPT, Grok bot, and the rest, and where fully cloud-based AI development looks like it stands from that.
I made a few products without a PC
First, what I actually made.
su-css
The first is su-css, a CSS library.
I started on Google AI Studio, then moved to Claude Code on the web.
I wrote zero of the code.
Google AI Studio was really good at the mockup experience.
Things take shape easily, and debugging is easy too.
On the other hand it would change things I hadn’t asked for, and it felt a bit awkward for growing a product over time.
Once you start thinking about ongoing development hooked up to GitHub, the experience still felt one step short.
The quality of what it generated wasn’t bad, but I wanted a bit more.
So partway through I moved to Claude Code on the web.
With Claude Code, I give instructions from my phone, it implements in the cloud, and it brings up a web page so I can check.
On top of that, it checks the screen itself and sends back screenshots.
I look at those screenshots on my phone.
If nothing’s particularly wrong, I merge pretty roughly.
It deploys to GitHub Pages, and at the end I check on a real phone.
If I find a problem on device, I take a screenshot, send it to Claude, and have it fix it again.
That was roughly the loop.
Used to be,
I wrote the code.
I started localhost.
I opened a browser.
I looked at DevTools.
I fixed the code.
I looked at the browser again.
I was the one doing that.
Write code, run it, look at the screen, fix it again.
I ran that whole lap myself.
This time, a large part of that sits with the agent.
What I do is look at the output and decide “OK” or “not that.”
When I give an instruction, the agent side doesn’t stop at implementation.
It runs spec tests, deploys, and even does a light code review and security review, as a loop outside me.
What comes back is that result. I look at the output and decide “OK” or “not that.”
Refreshing the personal blog
I also refreshed the personal blog with only Claude Code on the web.
Zero lines of code written by me here too.
Things like a website, where you can open a browser in the cloud and check the output as-is, fit AI agents unusually well.
The agent implements, checks itself, and shares the result as screenshots.
What’s left for the human is almost only review.
A mobile game
I’m also making a mobile game right now.
On this project I’ve been trying a few more services.
For planning I mostly used ChatGPT.
I had Claude and Gemini think through the same kind of planning, and for me ChatGPT’s answers were the best.
For development I tried Claude Code on the web and Cursor Cloud Agents.
I started design and implementation with Claude, but I wasn’t happy with the visual output.
So partway through I had Cursor rebuild a large part of it.
Cursor is very good when you have it make something you can check on the web.
On a virtual desktop, the agent checks the screen itself as it works.
And it wasn’t just that it ran. The visual quality was high too.
Right now, if you’re having it make a product you can check on the web, Cursor feels pretty strong.
As I kept making the game, though, I started wanting a game engine too, rather than the React Native I’d picked at first.
So now I’m also trying Grok bot.
Grok bot can work pretty flexibly on a virtual desktop.
It also seemed like a good fit for development environments that don’t finish in a simple browser, like a game engine.
The more interesting part is that you can run several bots as a team.
Token use is intense.
The experience is less “I’m having AI write code” and closer to giving instructions to a team with several people on it.
Separate from the short loop from implementation to review, on Grok I split roles and built a team.
Progress and product quality sit with a director.
Design quality sits with a creative director.
Design production sits with a designer.
I’ve only just started, but so far it’s pretty interesting.
I don’t actually want to use a lot of tools
Reading this far, it might look like I see value in picking a different AI service for each job.
That’s not actually how I feel.
Right now I’m trying several services to find the environment I want. In the end I want to collapse onto one as much as I can.
Use several services and you can combine what each is good at.
On the other hand, if you’re developing a product over time, the cost of bouncing between services is large.
You have to carry context across.
You have to keep GitHub in sync.
Auth is different.
The UI is different.
Pricing is different.
You have to learn the quirks of each service too.
In the short term, combining whichever AI is best at that moment might make a higher-quality thing.
As a sustainable development experience, finishing everything in one environment is better.
What I’m looking for is
an environment that’s fully in the cloud, with no runtime on my machine, where I can finish one product.
What I want is not a cloud IDE
“Cloud development environment” tends to mean VS Code running in a browser.
What I want right now is a bit different.
I don’t want an environment where I write code in the browser.
If anything, I want to write as little code as possible.
What I want is for the agent itself to have a runtime.
Plan.
Design.
Implement.
Run.
Check in a browser.
Debug.
Test.
Review for security.
Operate GitHub.
Deploy.
I want the agent side to finish all of that.
The human doesn’t clone the code locally.
Doesn’t npm install.
Doesn’t open an IDE.
Doesn’t start localhost.
The agent checks the output itself and shows the result to the human.
The human sets direction and evaluates the output.
That’s close to what I think of as the ideal shape of fully cloud-based AI development.
In personal projects I stopped reading code at all
In this round of personal work I almost never read the code.
I also don’t look at the diff line by line before merging.
What I check is the output.
Is it the feature I wanted.
Does it actually run.
Does the visual feel off.
Is there a serious quality problem.
For security too, I didn’t review all the code myself. This time I handed the review itself to the agent.
That doesn’t mean I stopped checking.
The way I check changed.
Instead of reading the code and hunting for problems, I hand over the job: “check this change for security issues.”
Then I judge the final output, including that result.
For me that was a fairly large shift.
Isn’t it scary not to read the code
For personal projects, I’m not that scared so far.
There is a condition.
Worst case, I can scrap it and rebuild.
It’s a new, small product. If there’s a problem I can throw it away and make it again.
At that scale, not fully understanding what code the AI wrote inside isn’t that scary.
Work code is not something I treat the same way.
On a product where I own the final quality, I still do a high-level check.
What feels scary is a codebase with a long history stacked up.
Old systems.
Tangled dependencies.
Tacit knowledge that isn’t in the docs.
Behavior that only happens in production.
Drift between development and production.
Code like that still feels too scary to hand entirely to an agent.
When you decide whether you can leave it to AI, the important question might not be “how much do I trust AI.”
It might be
how easy it is to start over when it fails.
The hard part is not code generation
The thing that gives me the most trouble right now in fully cloud-based AI development is not code generation.
It’s that I can’t check on a real device in sync and give feedback on the spot.
The hard case is when you’re tuning a visual.
If the requirements are clear, you can instruct pretty accurately in natural language.
Put the button here.
Make the gap this many px.
Under this condition, show this screen.
AI is pretty good at that kind of instruction.
But when you’re actually making a product, the instructions aren’t always that clear.
“It’s off somehow.”
“I want it a bit lighter.”
“This motion doesn’t feel good.”
“I want it more game-like.”
“In my head it’s more like this.”
You often start from a state that abstract.
And the person giving the instruction hasn’t fully put the finished thing into words either.
You actually touch it.
Something feels off.
You fix it a little.
You touch it again.
You look at that and think about the next direction.
Visuals get built inside that kind of trial and error.
Getting all of that across to an agent in natural language alone is pretty hard.
Right now I check on device, screenshot the part that feels off, and send that to the AI.
There’s obviously missing information there.
After which action did it happen.
At which moment did it feel off.
Which part of the animation feels wrong.
How did it feel when I actually touched it.
You can’t put that on one screenshot.
That’s the biggest bottleneck I feel in fully cloud-based AI development right now.
The value of a local environment was not writing code
Going through this, I noticed the reverse as well.
Local development environments were convenient not only because they’re easy to write code in.
The feedback loop is overwhelmingly short.
Change the code.
Look at the browser.
Actually touch it.
Something feels off.
Look at DevTools.
Fix it a little.
Touch it again.
You can run that loop almost unconsciously, and fast.
Even if AI automates a large part of “writing code,” if you lose this feedback loop, the development experience as a whole still isn’t fully replaced.
Put another way, what fully cloud-based AI development is missing right now might not be an even smarter code-generation model.
The bandwidth of context a human and an AI can share
feels like it matters more.
The ideal is a runtime a human and an AI can both touch
Ideally, I want to operate the same environment the AI is developing in, from my phone, in real time.
The AI is writing code.
I can also touch the output in that same environment.
If something feels off, I point at the screen right there.
I say “here.”
I explain out loud.
I record the interaction.
If I need to, I draw on the screenshot.
The AI understands not just the code but what I was doing and where it felt off.
If we get that far, I think a lot of development could finish with no local environment.
Current AI development environments are already quite strong at implementation itself.
The interface for a human and an AI to look at the same product and finish it together is still early.
Does this mean engineering jobs go away
Working this way, you naturally get to “what happens to the engineer’s job.”
At least for me, it doesn’t feel like the work shrank.
The center of gravity moved.
Time spent writing code definitely went down.
On the other hand, the tech-lead work got clearer.
What technology do we build the product with.
Which direction do we take it.
What counts as the quality bar.
How much do we leave to the agent.
At which point do we check.
When there’s a problem, do we have it fix, or throw it away and rebuild.
And who owns the quality of the final output.
That part doesn’t go away when AI writes the code. It matters more.
Lately it feels less like I’m having an agent write code, and more like
I’m managing a development team made of agents.
That feeling is especially strong with something like Grok bot, where several bots run as a team.
Who does what.
How far do you let them go on their own.
Who reviews.
If there’s a problem, you have someone else look into it.
It’s starting to look a bit like managing a human development team.
My role is moving from implementer to the side that sets technical direction, defines quality, and runs an agent team efficiently.
That’s not “you won’t need to be able to write code.”
If anything, the ability to set direction with an understanding of the tech, judge whether the output is good, and own that quality is getting more important.
That might become one of the things a tech lead needs from here.
I still haven’t found the environment I want
I’ve tried a lot, and I still haven’t found a service where I can say “just use this.”
Google AI Studio was good for making a mockup quickly.
Claude Code on the web is quite good as an experience of developing continuously in the cloud.
Cursor Cloud Agents is very strong for things you can check on the web, and the visual quality is high too.
ChatGPT is thin if you look at it as a cloud-complete development environment, but the quality of planning and design output is high, and being able to generate images in the same place is strong too.
Grok bot I’ve only just started, but I feel potential in the flexibility of the virtual desktop and in running several bots as a team.
What I’m aiming for is not a future where I juggle these skillfully.
One service that finishes planning, design, implementation, running, checking, debugging, testing, review, and deploy.
The human doesn’t keep a runtime locally.
You don’t need to open a PC to write code.
From your phone you instruct an agent team in the cloud, touch the same runtime, and review the output.
And the human owns technical direction and quality.
If that environment existed, I feel like the meaning of “development environment” in software would change quite a bit.
I’m not there yet.
But inside the physical constraints of parental leave, holding a baby, I’ve been able to make a few hobby products from my phone alone.
At that point, we’ve at least reached a place that wouldn’t have been thinkable before.
I’m in the middle of that.
🤖 Generated with ChatGPT