Inspiration

I'm a full-stack developer working across several teams, and a big part of my week is UI tickets: "the spacing is off," "make this match the mockup," usually with a screenshot attached. Each one means finding the component that renders the element, guessing what the reporter meant, and then explaining back in Jira what I changed.

I built GUIJam to fix the first half of that. It started as "Magic Canvas": draw on the app running in your dev server, describe the change, and keep it as a real source edit. (The name is a nod to FigJam.) One rule shaped everything: no AI API keys. GUIJam runs the AI coding CLI you're already logged into, headlessly.

Codegeist made me look at the other half. The ticket lives in Jira, and so do the PMs, QA and designers who wrote it. Ticket-to-UI connects the two: a ticket goes in, and visual proof of the fix comes out.

What it does

  • In Jira, anyone can click Send to GUIJam on a UI ticket.
  • In the developer's running app, the GUIJam toolbar lists their queued tickets. Opening one fills the prompt with the ticket's text and loads its screenshots as references.
  • The developer points at the element, and their own AI CLI (Claude Code, Codex, OpenCode, Gemini CLI or Qwen Code) generates three live variants right in the page. Simple requests like "make it blue and pill-shaped" become exact edits with no AI at all.
  • When they keep a variant, GUIJam writes a minimal edit to the source. Once the 10-second undo window closes, it posts back to the ticket: before/after screenshots, the file and line, the diff, and a status change.
  • A GUIJam panel on the Jira issue shows all of it, so whoever filed the ticket can review the fix without opening code or running anything.

How we built it

  • Forge app: an issue panel built with UI Kit, a "Send to GUIJam" issue action, an indexed issue property that makes guijamStatus searchable in JQL, and a web trigger that serves as a small, versioned bridge API to the developer's machine.
  • Secure pairing: the panel issues a one-time pairing code, and only its SHA-256 hash is stored in Forge storage. Before touching an issue, every bridge call checks that the paired user has permission for it, so the app's broader access never leaks to anyone.
  • GUIJam side: a Jira client in gjd, GUIJam's Rust daemon and the only process that writes to your project; new messages in GUIJam's shared JSON-schema contracts; a Tickets tool in the widget; and before/after capture that reuses GUIJam's existing page-capture code. The diff comes straight from GUIJam's undo journal, so it shows exactly what was written to disk.
  • No AI inside Jira: no Forge LLMs and no model APIs anywhere. All AI stays in the developer's own CLI.

Challenges we ran into

  • Uploading screenshots. I first wanted all Jira traffic to go through Atlassian's own CLI, to match how GUIJam drives AI CLIs, but it can't upload attachments. Moving the bridge into Forge solved that and made the Forge app the real core of the integration.
  • Securing a public endpoint. Forge web triggers are public and carry no user context, so I built the pairing flow and a per-request permission check for the paired user.
  • Undo vs. posting. GUIJam gives you 10 seconds to undo a kept change. Posting right away could put a change in Jira that no longer exists, so results post only after the window closes. A later undo posts a "reverted" note.
  • Untrusted ticket text. It's passed to the AI as data, not instructions, the CLI gets no write tools, and every edit is still checked against the current file before it's written.

Accomplishments that we're proud of

  • The whole loop, from Jira ticket to source edit to visual proof back in Jira, runs with no AI API keys, and GUIJam never stores an Atlassian credential.
  • Exact-edit tickets work with no AI CLI installed at all.
  • PMs, QA and designers get before/after proof inside Jira without running anything.
  • With Jira unpaired, GUIJam behaves exactly as it did before.

What we learned

  • How Forge works: modules, scopes, acting as the app versus as the user, and how much security work a public trigger needs.
  • Building for a team instead of a single developer shifts the hard problems from generation to permissions, attribution and timing.
  • Sticking to one principle ("your CLI, your login, no AI keys") made a lot of decisions easy.

What's next for GUIJam

  • Report to Jira: QA and designers running the app can select an element and file a ticket with its screenshot and exact file and line.
  • Atlassian MCP tools, so any AI agent can read GUIJam's context on a ticket.
  • A Marketplace listing, and support for more AI CLIs.
  • Support for Angular and the Next.js Pages Router.

Built With

Share this project:

Updates

Submission history