sebringj

i do not submit things to hacker news unless its related to my favorite tool ever, literally, that i happened to have made. i made this out of being super lazy and wanted my copilot (works in all ai editors) to run my UI while its coding and validate it at the same time by using the apps. i don't know how to contain how good this is for me to use other than putting it here for people to look at. so using it with opus 4.5-4.6 its extremely good, however using it with gpt-5.3 its still good but you have to remind it to use the "autonomo help" when it forgets how to use it correctly sometimes.

anyways, please check it out if you are curious and want very fast efficient UI driven (multi app/web/desktop at the same time, agnostic) validation while you vibe. I just keep using it everyday but still waiting for something to just make this obsolete.

web page:

https://sebringj.github.io/autonomo/

github:

https://github.com/sebringj/autonomo

Built something small to stop the endless "it works on my machine" loop with AI assistants.

Autonomo lets your AI actually see the app state, drive UI elements across devices, and verify changes in real time—right from your copilot or cursor etc. No more blind code suggestions.

If you're tired of AIs that talk big but can't prove it on real hardware, give it a spin and let the AI take the wheel for a bit. This is for apps only though so it's optimized for speed, not generic vision or specific device.

https://sebringj.github.io/autonomo/ Curious if anyone else is experimenting with giving agents proper eyes/hands in dev loops.

When you address your own problem and it works really well, that is when you go ok this actually could help other people.

My issue started as taking on a side project sports league app and web as it was insane to attempt as a solo dev – all-in-one sports community with social feed, league mgmt, live broadcasting, payouts for trainers/refs, travel/venue bookings, waze type live field conditions, AI assistant gluing it all together. web + ios + android + desktop as a solo dev. do everything to matter in this space in other words, every small tweak (chat sync, payment edge case, broadcast switch, booking conflict, field update prop, AI response consistency) meant i had to spin up browser + ios sim + android emu + desktop, play different roles (fan/player/parent/coach/ref/vendor/manager), manually poke everything, stare to see if sync held without desync/crash/security fuckups. There was just not enough time to get it done within a year if I had to manually check things worked every time.

I thought ok if AI coding can actually see and drive to check its work but in a meaningful deeper way, that would let it stop proclaiming "It worked!" when it didn't. What if it could actually know while its developing? In the past I worked with puppeteer, playwright for web and tried some mobile stuff that seemed very heterogeneous and even tried vision calls that was super expensive. None of those would be deep enough anyway, I needed one approach and those others were also slow or super expensive with vision, there had to be a better way. Why not JSON state that bubbles up server errors too with a local socket server making it fly?

I was in shock for 2 days that it worked so well. It just built out the apps in about a month as it could go build -> verify did it work? -> iterate (repeat) -> done... but this time done meant it actually tried it and it worked and could even interplay devices across web and mobile. So my problem is now trying to show my sports connected, non tech cofounder how to use it so he can give meaningful demos to prospective clients.

Meanwhile, it might just be worth your time to check out autonomo mcp.

https://sebringj.github.io/autonomo/ https://github.com/sebringj/autonomo

Hoping to see where it evolves with enough feedback as I tend to be a hermit in a vacuum.

AI agents (Cursor, Claude computer-use, Copilot agent mode, etc.) have gotten stupidly good at spitting out code. Prompt → boom, clean code. The marketing says "it just works."

It fucking doesn't.

You run it in a real app and immediately hit the same bullshit wall every time: - Hallucinated logic only reveals itself under real data or edge cases - UI updates magically forget to sync across devices (mobile → web = sad trombone) - API calls quietly return 401s or other crap that gets swallowed in some lazy try-catch - Vision-based agents crawl like molasses (2–10s per action) and torch tokens like it's free - Background pings and unrelated fetches make it impossible to tell what actually caused what

I tried pretty much everything out there and none of it quite scratched the itch I had: fast, structured, cross-platform runtime visibility without vision bloat or having to wire up a ton of hooks.

Quick rundown of the usual suspects:

- Pure vision/computer-use (Claude 3.5/4, ADEPT-style): zero setup, works on anything — but latency from hell and token burn is brutal for anything longer than a demo - Playwright / browser MCP servers: fast and structured for web — but web-only, selectors shatter like glass, no native mobile - Appium + vision hybrids: cross-platform on paper — but still vision-dependent and setup is a pain - Sandboxed agents (OpenHands, SWE-agent): decent for repo tasks and shell stuff — not so much for live app UI/network state - Explicit hooks/bridges: precise when you bother adding them — but requires code changes, which sucks

Couldn't find anything that gave me low-latency structured JSON state (UI elements, network, errors, logs) across platforms, local-first, without the usual trade-offs. So yeah, I got fed up and built a small local MCP server to solve it for myself.

Full disclosure: it's called Autonomo MCP https://github.com/sebringj/autonomo — very early, just launched.

I don't usually do this "I built a thing" thing — my open-source contributions are mostly small fixes and PRs — but I honestly couldn't see a better way in the current landscape.

It is my hope that Anthropic (or someone) will eventually ship a clean native solution for this. They already fixed BM25 tool calling to shrink context like crazy; I'd love to see them (or the industry) make runtime validation "just work" out of the box too.

Sometimes when you code in a vacuum you think your shit smells good. lmk if I'm off base here, I grew up with a mean grandpa so I'm cool with it.