As a product manager turned software engineer, I’ve always wanted a way to prototype directly on the actual product, without recreating mockups in Figma.
So I built Airship. It lets you prototype directly on your actual product. Select a UI element, describe what you want to change, and experiment directly in your running app.
It’s fully open source and MIT licensed. Made with <3 for fellow PMs.
I wanted to experiment with my UI the way I do in Figma, without having to rebuild it in a separate design tool.
So I built Airship.
It wraps your existing dev server and lets you prototype directly in your running app — select elements, make changes, and explore different directions visually. No plugins or build changes required.
When you find something you like, Airship applies the changes back to your source. No mockups to keep in sync, and no bouncing back and forth between design and code.
Airship is MIT licensed and fully open source. Feel free to fork it, modify it, or make it your own.
If you try it, I'd love to hear what worked (and what didn't) :)
Link to the project in the comments.
I wanted to experiment with my UI like I do in Figma, without having to rebuild it in a separate design tool.
So I built Airship. It wraps your dev server and lets you prototype directly in your running app, select elements, make changes, and explore different directions visually.
Once you like something, Airship applies the changes to your source. No mockups to keep in sync, or bouncing back and forth between design and code.
Link to the project in the comments below :D
I’ve recently started doing playtests for games on Steam and I’m starting to notice how different each experience can be depending on the game and the devs behind it.
Some playtests feel really smooth, well-structured, and actually fun to be part of, while others feel a bit confusing or unorganized.
So I wanted to ask:
Which Steam games have you playtested that had some of the best overall playtesting experience?
Also, if you’ve had any *bad* experiences that taught you what to avoid, feel free to share those too.
I’m still pretty new to this space, so I’m trying to learn what good playtesting setups actually looks like from the player side.
Thanks in advance
I’ve recently started doing playtests for games on Steam and I’m starting to notice how different each experience can be depending on the game and the devs behind it.
Some playtests feel really smooth, well-structured, and actually fun to be part of, while others feel a bit confusing or unorganized.
So I wanted to ask:
Which Steam games have you playtested that had some of the best overall playtesting experience?
Also, if you’ve had any bad experiences that taught you what to avoid, feel free to share those too.
I’m still pretty new to this space, so I’m trying to learn what good playtesting setups actually looks like from the player side.
Thanks in advance
If you're using Claude, Codex, or Cursor to build things, this would save you a lot of time.
I've been working on Canary, an open-source QA harness that hooks into your coding agent and validates UI flows in a real browser whenever code changes.
It reads the diff, figures out what's likely affected, runs those flows, and captures:
No more clicking through your app by hand after every code change.
MIT licensed, ships as a skill for Claude, Codex, and Cursor.
I've been working on an open-source project called Canary.
Canary reads code diffs, identifies likely affected UI flows, and uses Claude Code to validate those flows in a real browser.
Each run captures:
Every run also generates a replayable Playwright test that can be rerun locally or in CI with zero inference cost.
Under the hood, Canary exposes the Playwright API to Claude through a QuickJS WASM sandbox, allowing it to handle complex browser workflows while keeping the entire session observable.
Try it out. Links in the comments below :D
So I just shipped an open-source QA harness built specifically for coding agents like Claude.
It analyzes your code diffs, identifies the UI flows that were affected, and tests them in real browser using Claude Code.
Instead of manually clicking through flows to reproduce and verify issues, Canary gives you complete session recordings, console logs, network requests, HAR files, and Playwright traces. So you can see exactly what the agent did and where things went wrong.
Canary is available as a plugin for Claude, Codex, and Cursor.
Links in the comments below. Give it a try, fork it, improve it, make a product out of it, make it yours :D
I'd love to hear what worked, what didn't, and any feedback you have
https://reddit.com/link/1tzcufh/video/ka2jlpha9v5h1/player
Just shipped an open-source QA harness purpose built for coding agents like Claude. It reads your code diffs, identifies the affected UI flows, and tests them in real browser instances using Claude Code.
Instead of clicking through flows by hand to reproduce and verify issues, Canary provides full session recordings with console logs, network requests, HARs, and Playwright traces so you can inspect exactly what the agent did.
Canary ships as a plugin for Claude, Codex, and Cursor. Links in the comments below
Give it a go, happy to hear what worked (and what didn't :D)
https://reddit.com/link/1tzcr2p/video/llqjrost7v5h1/player
Just shipped Canary, a QA harness purpose built for coding agents like Claude Code. It reads your code diffs, identifies the affected UI flows, and tests them in real browser instances using Claude Code.
Instead of clicking through flows by hand to reproduce and verify issues, Canary provides full session recordings with console logs, network requests, HARs, and Playwright traces so you can inspect exactly what the agent did.
Under the hood, it ships with a QuickJS WASM sandbox exposing the full Playwright API, letting Claude automate any long-running UI task — from handling logins to navigating complicated UIs.
Canary ships as a plugin for Claude, Codex, and Cursor. Give it a go, happy to hear what worked (and what didn't)
Just shipped Canary, a QA harness purpose built for coding agents like Claude Code. It reads your code diffs, identifies the affected UI flows, and tests them in real browser instances using Claude Code.
Instead of clicking through flows by hand to reproduce and verify issues, Canary provides full session recordings. You get screen recordings with console logs, network requests, HARs, and Playwright traces so you can inspect exactly what the agent did.
Under the hood, it ships with a QuickJS WASM sandbox exposing the full Playwright API, letting Claude automate any long-running UI task — from handling logins to navigating complicated UIs.
https://reddit.com/link/1tywh4s/video/cxhw86n21r5h1/player
Plus every Canary run captures a reusable Playwright script. Letting you re-run it in CI with zero inference cost on replay.
Most testing tools make you pick between two extremes:
Canary doesn't: the agent does the QA and hands you a reproducible script.
I've been working on an open-source project called Canary.
It takes a code diff, identifies the UI flows that are likely affected, and then uses Claude Code to test those paths in a real browser.
Every run captures video, screenshots, network traffic, HAR files, console logs, and Playwright traces.
The result is both a validation run and a replayable Playwright script.
Canary is an open-source QA harness built for coding agents.
https://reddit.com/link/1tyul6s/video/rlmcp0qkmq5h1/player
It reads code diffs, identifies affected UI flows, drives a real Chromium instance using Claude Code, and records everything: screen, console, HAR, Playwright traces. Every session generates a Playwright script for CI replay.
Ships as plugins for Claude Code, Cursor, and Codex. MIT licensed.
Lately I've been experimenting on an open-source project called Canary.
It takes a code diff, identifies the UI flows that are likely affected, and then uses Claude Code to test those paths in a real browser. Every run captures video, screenshots, network traffic, HAR files, console logs, and Playwright traces.
The result is both a validation run and a replayable Playwright script.
Lately I've been working on an open-source project called Canary.
It takes a code diff, identifies the UI flows that are likely affected, and then uses Claude Code to test those paths in a real browser.
Every run captures video, screenshots, network traffic, HAR files, console logs, and Playwright traces.
The result is both a validation run and a replayable Playwright script.
I've been working on a small open-source project called Canary.
The idea is pretty simple: when you make a code change, Canary spins up a real browser, tests the affected UI flows, and records everything you'd want when debugging a test run—screen recordings, console logs, network requests, HAR files, Playwright traces, and screenshots.
One thing I like is that every run also produces a replayable Playwright script, so if the validation succeeds you can rerun it later without involving the model again.
Hey folks, I just shipped Canary. It reads the code diff, identifies which UI flows are affected, builds a QA plan, and drives a real Chromium instance through those flows using Claude Code.
Each run captures screen recordings with console logs, network requests, HARs, and Playwright traces. Letting you inspect exactly what the agent did.
Ships as plugins for Claude Code, Cursor, and Codex
I’ve been working on an open-source project called Canary. It reads code diffs, understands the affected UI flows, and uses Claude Code to validate code changes in real browser.
Each run captures:
Every run produces a real Playwright script you can replay in CI and a Playwright trace you can view in npx playwright show-trace :)
I've been working on an open-source project called Canary. Canary reads code diffs, determines which UI flows are likely impacted, and uses Claude Code to validate those flows in a real browser.
Every session records:
Each run generates a Playwright script that can be replayed later without involving the model again. The generated test can run locally, in CI, or as part of an existing Playwright suite.
Under the hood, Canary uses a QuickJS WASM sandbox that exposes the Playwright API to Claude Code while keeping execution deterministic and observable.
I've been working on an open-source project called Canary. It reads your code diffs, understands which UI flows are likely affected, and lets Claude Code tests those flows in a real browser.
Under the hood, Canary ships with a QuickJS WASM sandbox that exposes the full Playwright API, allowing Claude to perform long-running browser workflows such as authentication, onboarding flows, form submissions, and navigation across complex applications.
Each run captures:
Unlike most agent runs, every Canary session also generates a reusable Playwright script that can be cleaned up and replayed locally or in CI with zero inference cost.
