u/ivanzhaowy

I’m building Monad Design, a local visual workspace for developers using coding agents on existing native-app repositories.

The gap I kept hitting was visual context. A prompt like “the spacing on this screen feels wrong” does not tell the agent which rendered state I mean, which element I’m pointing at, or what changed after the edit.

The workflow I’m testing is:

1. Run the real Xcode or Expo iOS project in Simulator.

2. Navigate to the exact UI state.

3. Select an element or annotate directly over the running app.

4. Send the screenshot, selection, app state, and source hints to the coding agent.

5. Let the agent edit the existing repository and rebuild.

6. Compare the original with several working variants, then accept one or keep the original.

The app remains the source of truth—Monad Design does not generate a replacement project. It adds a visual review loop around agents such as Codex, Claude Code, Cursor, OpenCode, Gemini CLI, Copilot, Windsurf, and Zed.

Current scope: macOS with local iOS development, one active visual change at a time.

It’s free and open source under Apache-2.0:

https://github.com/Monadix-AI/monad-design

For people working across frontend and mobile code, where does visual context break down most often in your agent workflow: identifying the right element, reproducing the state, or reviewing the result?

https://preview.redd.it/afsdiu7kh1oh1.png?width=3456&format=png&auto=webp&s=e0db29090042c7ca244df875d5b21e4029eb757d

I’m building Monad Design, an Apache-2.0 open-source workspace for giving coding agents grounded visual context from a running native app.

The problem is that an agent can inspect source code, but “this spacing feels wrong in this exact simulator state” is still awkward to communicate. Monad Design turns that into a local loop:

1. Run an existing Xcode or Expo iOS project in Simulator.

2. Select an element or annotate the rendered screen.

3. Package the screenshot, selection, annotations, app state, and source hints for the coding agent.

4. Let the agent edit the real repository and rebuild.

5. Compare the original against up to five working variants, then accept one or keep the original.

It currently runs locally on macOS and works with agents including Codex, Claude Code, Cursor, OpenCode, Gemini CLI, GitHub Copilot, Windsurf, and Zed. The current preview supports one active visual change at a time.

Repository: https://github.com/Monadix-AI/monad-design

For people building open agent tooling: would you expose the visual context as one structured handoff bundle, or as smaller composable tools for screenshot, selection, annotation, app state, and source mapping?

https://preview.redd.it/jk0xjbiqd1oh1.png?width=3456&format=png&auto=webp&s=c5371f062b825d823b3320ec8234f649a283e7ae

The part of AI-assisted development I kept losing time on was the handoff between “this screen feels off” and a source change I could actually review.

I’m building Monad Design to make that handoff concrete. It works with an existing Xcode or Expo iOS repository rather than generating a replacement app.

The workflow is:

1. Run the app in a local iOS Simulator and navigate to the exact state.

2. Select an element or annotate the screen with arrows, shapes, text, and notes.

3. Send that visual context to the coding agent already working in the repository.

4. Let the agent edit the real source and rebuild.

5. Compare the original with up to five working variants, then accept one or keep the original.

It currently works on macOS for local iOS development and supports agents including Codex, Claude Code, Cursor, OpenCode, Gemini CLI, GitHub Copilot, Windsurf, and Zed. The current preview handles one active visual change at a time.

The project is free and open source under Apache-2.0:

https://github.com/Monadix-AI/monad-design

I’d be interested in how other tool builders would package the first agent handoff: one bundle containing the screen, selection, annotation, app state, and source hints—or smaller tools the agent calls separately?

https://preview.redd.it/xtbeqpt6a1oh1.png?width=3456&format=png&auto=webp&s=cddcb24bbf2776091f1e255d4ee9ff5f797b2f28

I’m building Monad Design, an Apache-2.0 visual implementation workspace for coding agents and existing native mobile apps.

Coding agents can already read and edit a repository, but visual changes still tend to start with a long explanation or a detached screenshot. Monad Design keeps that feedback connected to the app that is actually running:

- Open an existing Xcode or Expo iOS repository.

- Run the app in a local iOS Simulator and navigate to the exact state.

- Select an interface element or annotate the screen.

- Send that context to Codex, Claude Code, Cursor, OpenCode, or another supported local agent.

- Let the agent edit the existing source, rebuild, and compare the original with real variants before keeping one.

It is not a prompt-to-app generator and does not create a replacement project. The current preview is for local iOS development on macOS, with one active visual change at a time.

Repository: https://github.com/Monadix-AI/monad-design

I’d especially value technical feedback on two parts of the workflow: mapping selected UI back to the most useful source context, and preserving the exact app state across rebuilds.

https://preview.redd.it/k6pbpnm791oh1.png?width=3456&format=png&auto=webp&s=294eb62b6b996e0ad70790d3d84e4c860d616170

When I use a coding agent on an Expo app, the slow part is often describing what I’m looking at: “the second card, in this state, after opening that sheet.” A screenshot helps, but the agent still has to guess which part of the project it belongs to.

I’m building Monad Design around a simpler idea: the app is the canvas.

It opens an existing Expo iOS project, connects to the running Simulator, and lets me select or annotate the UI in the exact state I care about. That context goes to the coding agent I already use. The agent edits the real repository, the app rebuilds, and I can compare the original with a few working variants before keeping one.

The useful part for me is that it doesn’t generate a separate prototype. The result stays in the Expo project, so there’s no design-to-code handoff afterward.

Current scope is local iOS development on macOS. It’s open source and works alongside Codex, Claude Code, or Cursor.

Repo: https://github.com/Monadix-AI/monad-design

I’m the creator. Happy to explain the Expo integration or any of the tradeoffs behind it.

https://preview.redd.it/w5haqn1s4hnh1.png?width=3456&format=png&auto=webp&s=bc5e1bcb7f82f8ec06dc8e495893db161107d219

Screenshots worked reasonably well when I was starting a screen from scratch. Once the app had real navigation, data, and several UI states, they became a pretty bad way to explain a visual change.

The screenshot showed what I could see, but not how I got there, which element I meant, or whether the change still worked after rebuilding the app.

That’s why I’m building Monad Design around a different idea: the app is the canvas.

You navigate through the running iOS app, select or annotate the UI in place, and describe the change there. The coding agent edits the existing source and rebuilds the same project. For subjective changes, it can produce a few real implementations so you can compare them with the original before choosing one.

https://preview.redd.it/gqvkfvnokgnh1.png?width=3456&format=png&auto=webp&s=3c777223d371f0a10f3c9d74425eb11828310b1a

It’s not another mockup generator, and it doesn’t create a separate project that has to be translated back into the app.

I’m the creator of Monad Design. I’m curious how other indie developers handle this stage: once the app works, what takes longer—explaining the visual change or deciding whether the result is actually better?

When I use a coding agent on an existing iOS app, the slow part usually isn’t writing the SwiftUI. It’s explaining which screen state and which element I’m talking about, then checking whether the result actually feels right in the app.

I’m building Monad Design around a simpler idea: the app is the canvas.

You run the real Xcode project in Simulator, navigate to the state you care about, and select or annotate the UI directly. Your existing coding agent edits the source and rebuilds the app. If the change is subjective, you can ask for a few implementations and compare them with the original before keeping one.

https://preview.redd.it/scv3wvjrhgnh1.png?width=3456&format=png&auto=webp&s=bcfa85e5c36cc6b88d6b83f16d5d223a01b1d513

It doesn’t generate a separate mockup or move the project into another platform. The work stays in the existing codebase, and the diff stays visible in Git.

Right now it runs locally on macOS and works with existing iOS projects. I’m the creator.

https://design.monadix.ai

For people already using agents on SwiftUI: is describing the change still the annoying part, or is reviewing the result the bigger bottleneck?

I kept running into the same problem when using coding agents on native UI: the change I wanted was obvious when looking at the app, but surprisingly awkward to explain in text.

So I’m building Monad Design around a simpler loop.

Open the real app, navigate to the screen you care about, then select or annotate the UI directly. Codex or Claude Code gets that visual context, edits the existing SwiftUI or Expo project, rebuilds it, and shows the result back in the app.

For changes where there isn’t one obvious answer, you can keep the original next to a few real implementation variants and compare them before deciding what stays.

The app is the canvas — not a mockup, and not a generated replacement project.

It runs locally on macOS and the source changes remain normal, inspectable Git changes:

https://design.monadix.ai

I’m the creator. I’d be curious how other people communicate subjective UI changes like spacing, hierarchy, density, or “this just doesn’t feel right” to coding agents.

https://preview.redd.it/nil39so7fgnh1.png?width=3456&format=png&auto=webp&s=bb3f8014285792c23f37a0d63dbdb81511c0f438

Most AI design tools start from a prompt and generate another screen or another project.

I’m building Monad Design for the point after the app already exists.

Run the real Xcode or Expo iOS project, navigate to the exact state, select or annotate the UI, and describe what should change. Codex or Claude Code edits the existing source and rebuilds it. You can then compare the original with a few real implementations before deciding what stays.

The app is the canvas.

It’s for native developers and product designers who want tighter visual iteration without moving their project into a hosted app generator or replacing the coding agent they already use. The workflow stays local on macOS, and the source changes remain inspectable in Git.

https://design.monadix.ai

I’m the creator. For teams already using coding agents on mobile UI: what part of subjective feedback—spacing, hierarchy, density, or alternative layouts—is still hardest to communicate?

https://preview.redd.it/5khzf10smfnh1.png?width=3456&format=png&auto=webp&s=7f52daac76759c33df0626e4d4f8d9b832a42909

When I started building Monad Design, the obvious pitch was “an AI tool that designs and codes mobile apps.”

That turned out to be too broad—and honestly, not very useful. Codex, Claude Code, and Cursor already handle repositories well. I didn’t need to replace them. The missing piece was the visual context around an existing native app.

So I narrowed the product down to one loop:

Run the real app, navigate to the exact state, select or annotate the UI, and describe the change. The coding agent edits the existing source and rebuilds it. Then you compare the original with a few source-backed alternatives before deciding what stays.

The app is the canvas.

That boundary made the product easier to explain and harder to fake. It isn’t generating a disposable mockup or replacement project. The change still has to work with real navigation, data, platform behavior, and Git history.

Monad Design currently runs locally on macOS with existing Xcode and Expo iOS projects. It’s an open-source preview, so there’s no revenue story yet.

https://github.com/Monadix-AI/monad-design

I’m the creator. The lesson I’d pass on to other small-tool builders: before replacing a workflow people already trust, look for the missing layer around it.

https://preview.redd.it/tu73k6tzifnh1.png?width=3456&format=png&auto=webp&s=278dc9edf58f5b4141a2c694ab5df55970a26011

There’s a context gap I kept hitting while polishing SwiftUI screens with coding agents.

I could see the exact problem in Simulator, but the agent only had my description, a file name, or a screenshot with “the card below the header” circled on it. Small visual changes turned into a lot of translation.

I’m building Monad Design around the idea that the app itself should be the canvas.

You open an existing Xcode project, navigate to the real screen state in Simulator, and select or annotate the UI that needs work. The coding agent edits the actual SwiftUI source, the app rebuilds, and the results return as source-backed variants you can compare before accepting one.

It doesn’t generate a separate mockup or replace the project. The repository and Git history stay in control; the running app just becomes the shared visual context.

The screenshot shows the compare step after generating a few alternatives.

https://github.com/Monadix-AI/monad-design

I’m the creator.

https://preview.redd.it/lf5k1wn6dfnh1.png?width=3456&format=png&auto=webp&s=5ae95e1089286d797bb04f0a1cf97ffbd44ba7b1

Starting an app with an agent is the easy, fun part. The awkward part comes later, when the app has navigation, real data, and a UI that is almost right.

That’s when I got tired of taking screenshots and explaining “the second row under the header.”

I’m building Monad Design around a simpler idea: the app is the canvas.

Open the existing Xcode project, navigate to the real state in Simulator, then select or annotate what needs work. The coding agent edits the SwiftUI source in the same repo, the app rebuilds, and the results come back as source-backed variants you can compare before keeping one.

It isn’t an app generator or a detached mockup tool. Git stays the source of truth, and it works with the local coding agent you already use.

The screenshot shows the compare step after asking for a few alternatives.

https://github.com/Monadix-AI/monad-design

I’m the creator.

https://preview.redd.it/r7005fftbfnh1.png?width=3456&format=png&auto=webp&s=e7d7b669f83251e41f896d96e3878fa73c80763a

I’m building Monad Design after getting tired of a very specific loop: notice a UI problem in Simulator, take a screenshot, explain which screen it came from, describe the element I mean, then hope the coding agent changes the right view without disturbing the rest.

The idea is simple: the app is the canvas.

Monad Design connects the mobile project you already have to the coding agent you already use. You navigate to the real screen state, select or annotate what should change, and send that context to the agent. It edits the actual source, the app rebuilds, and you review the result in the running app.

When the direction is unclear, you can ask for a few source-backed variants and compare them with the original before accepting one. It’s not generating a replacement app or a detached mockup—the repository stays the source of truth.

The current version runs locally on macOS and supports existing Xcode and Expo iOS projects. It works alongside Codex, Claude Code, Cursor, and other coding agents.

I’m the person building it. If you already use coding agents for native mobile UI, Monad Design is worth a look:

https://github.com/Monadix-AI/monad-design

I’m curious where other people lose the most context today: selecting the right view, describing the visual change, or reviewing what the agent changed?

https://preview.redd.it/rz4d1v3zlanh1.png?width=3456&format=png&auto=webp&s=c954b175322a6776cee5bbaaa58642f8cd5e9326

https://preview.redd.it/s6y7o8cl49nh1.jpg?width=3456&format=pjpg&auto=webp&s=8e9c5654e48f99c20181058f381e220cc640f940

I've been experimenting with a design-system workflow where the running app is the review surface.

Monad Design connects an existing SwiftUI or Expo project to a coding agent. I select a real view in Simulator, annotate the change, and the agent works in the repository that already contains the tokens and components. After rebuilding, I can compare the original with a few source-backed variants before accepting one.

What I like about this for design-system work is that the result isn't a screenshot someone has to recreate later. The proposed UI is already using—or visibly failing to use—the system in code.

I'm building Monad Design. It's local and open source:

https://github.com/Monadix-AI/monad-design

I’ve been working on an open-source macOS tool called Monad Design. The idea is simple: when a coding agent is changing native UI, the running app should be the canvas.

The macOS workspace connects an existing Xcode or Expo iOS project to Simulator. You navigate to the real screen, select a view or annotate an area, and send that visual context to the local coding agent you already use. The agent still edits the actual repository; Monad Design handles the handoff, rebuild, and review loop.

The trickier part hasn’t been drawing over Simulator. It’s keeping the selected screen state, the source change, the rebuilt target, and the review result connected. For subjective work, I also wanted the original to remain visible beside a few source-backed variants until one is chosen.

https://preview.redd.it/x5u7pzost8nh1.png?width=3456&format=png&auto=webp&s=e3ebe9d85f77576d9fcce71c7e1725a43ce0a52e

The current preview runs locally on macOS. It isn’t an App Store product or a separate app generator, and there’s no waitlist.

Source and setup notes:

https://github.com/Monadix-AI/monad-design

Short demo:

https://watchclueso.com/embed/pio8jqfcg4ivj0r1

I’m building Monad Design and would be interested in feedback from people who have worked on Xcode, Simulator, or other macOS developer-tool integrations.

One thing I keep running into with SwiftUI work is that screenshots lose the part that matters. They show the pixels, but not which view I mean, the current navigation state, or what should stay untouched.

I’m building an open-source tool called Monad Design around a more direct loop. You run an existing iOS project in Simulator, navigate to the real screen, select a view or annotate the area, and describe the change there. The coding agent still edits the SwiftUI source in the existing repo, then rebuilds the same target for review.

The most useful case for me is subjective UI work. I can keep the original next to a few source-backed variants, compare them in the same screen state, and choose one before treating anything as final.

https://preview.redd.it/718y4v1xq8nh1.png?width=3456&format=png&auto=webp&s=4f5849e09275f2a88794e03d3da4ecf227119be8

The app is the canvas. There isn’t a separate mockup that has to be translated back into SwiftUI.

Source: https://github.com/Monadix-AI/monad-design

Short demo: https://watchclueso.com/embed/pio8jqfcg4ivj0r1

It currently runs locally on macOS and works with Xcode and Expo iOS projects. I’m building Monad Design, so this is a project post rather than an unaffiliated recommendation.

I kept running into a strange mismatch with coding agents: the UI problem was obvious in Simulator, but turning it into a precise text prompt took longer than it should.

So I’m building Monad Design. It works with an existing Xcode or Expo iOS project. You navigate to the real screen, select an element or draw on the UI, and pass that context to the coding agent you already use. The agent edits the actual repo, rebuilds the target, and the result comes back for review.

The part that took the most thought wasn’t generation. It was review. For subjective changes, Monad Design keeps the original next to a few source-backed alternatives until you choose one. The app is the canvas; there isn’t a separate mockup to keep in sync.

https://preview.redd.it/lzljp15qp8nh1.png?width=3456&format=png&auto=webp&s=b3e8e390038c83972af15306987de2c2815faa4b

It’s an open-source preview, runs locally on macOS, and there’s no waitlist. I use coding agents heavily while building and testing it, but the product itself is agent-neutral.

Repo: https://github.com/Monadix-AI/monad-design

95-second demo: https://watchclueso.com/embed/pio8jqfcg4ivj0r1

If you’re building developer tools around visual context or human approval, I’d be interested to hear how you handle this loop.

Disclosure: I’m building Monad Design.

Been building something that I think is relevant to this sub.

The idea: you built your OpenClaw setup for yourself. Monadix opens up something new — other people's AI assistants can now hand work to yours, and yours gets paid per task it completes.

Your setup doesn't change. It just has a new source of work it can take on.

We're very early, and I want to be upfront about that. Feedback from people actually building things is more valuable to us than almost anything else right now.

For Creators who join in the early stage:
→ Monthly AI model credits
→ A lower take rate on your earnings — for the first batch, we're working toward making it permanently zero

Currently works with OpenClaw and Hermes. On a different framework and want in — I'd love to hear from you.

Happy to answer any questions.