From Figma to GitHub, with tickets and notifications built in — you control every step.

PixelFrame is a design-to-dev orchestration platform that connects Figma, GitHub, Jira, Linear, and Slack. We provide version control for designs, property-level change detection, AI-powered spec generation, automated pull request creation, and real-time team notifications. Design changes flow automatically into tracked tickets, generated code, and team alerts — all in one connected platform.

PixelFrame integrates with:

• Figma — Plugin for design sync, change detection, and version control
• Jira & Linear — OAuth integration for ticket creation and automatic PR linking
• GitHub — App for repository indexing, automated PR creation, and GitHub Issues export
• Slack — Real-time notifications for design commits, specs, and PRs
• Markdown — Export specs as Markdown for documentation or manual workflows

When connected, design changes can flow into tickets, PRs, and notifications — all on-demand with your approval.

PixelFrame uses semantic search to index your codebase (up to 200 files). When you generate a PR:

1. Embeddings are generated for your repository files
2. Semantic search finds files relevant to the spec
3. Claude sees your existing code patterns and architecture
4. AI generates code based on change type:
   • Added screens — Scaffolds entire new components, routes, and registration
   • Modified screens — Targeted changes (typically 3-20 lines)
5. A pull request is created on a feature branch

File paths are validated to prevent hallucinations. Your team reviews the PR, adds business logic, and merges like normal.

PixelFrame provides Git-like version control for Figma designs:

• Baseline snapshots — Property hashes track the state of each screen
• Change detection — Added, modified, and removed screens are identified
• Property-level diffs — Exact changes (colors, spacing, text) are tracked
• Commit history — Full timeline with named versions
• Rollback — Restore any previous version

All spec content is derived from actual design diffs — no generic statements:

• Adaptive titles — "Update Button Background Color on Login" (not "Update Login Screen")
• Specific user stories — Reference actual property values (e.g., "#2B5CE6 instead of #3B82F6")
• Diff-based criteria — One acceptance criterion per design change
• No generic fluff — No "matches specifications" or "maintains functionality"

When you export a spec to Jira or Linear:

• A ticket is created with the full spec content, screenshots, and deep links
• If you later generate a PR from that spec, the PR URL is automatically posted to the ticket
• The ticket and PR remain linked in PixelFrame for status tracking

This bidirectional linking means design changes, tickets, and PRs stay connected without manual copy-paste.

PixelFrame sends real-time Slack notifications for:

• PR Created/Failed — Immediate feedback when code is generated
• Spec Created — When new specs are saved to your backlog
• Version Committed — When design versions are synced from Figma
• Project Imported — When new projects are added

You can route different event types to different channels (e.g., PRs to #engineering, design updates to #design).

No. You can use PixelFrame incrementally:

• Figma only — Version control, change detection, and visual diffs
• + Jira/Linear — Export specs as tickets
• + GitHub — AI-powered PR generation
• + Slack — Team notifications

Each integration adds more automation, but you can start with just the pieces you need.

No. Every action requires your explicit approval:

• Specs — AI generates a preview. Nothing is saved until you click "Save to Specs"
• Commits — You review detected changes and choose which to commit
• Exports — You click "Export to Jira/Linear" when the spec is ready
• PRs — You click "Generate PR" to trigger code generation
• Merge — You review and merge PRs in GitHub like normal

AI proposes, you approve. Specs are editable, commits are curated, PRs are on-demand.

PixelFrame supports UI scaffolding for:

• Android — Kotlin / Java with Jetpack Compose
• iOS — Swift / SwiftUI
• React — Next.js, Remix, React Router (TypeScript / JavaScript)
• React Native — Expo Router, React Navigation
• Flutter — Dart with GoRouter or AutoRoute
• Vue — Vue 3 with Vue Router

AI detects your stack from file patterns and matches your coding style and architecture.

PixelFrame resolves Figma variable IDs to actual token names and values. This means diffs show "pf-color-primary" instead of just "#7C3AED". Token compliance is tracked so you can see when hardcoded values should be replaced with design system tokens.

PixelFrame separates code understanding from code storage. Your source code is never stored on our servers — we only store lightweight mathematical representations (embeddings) for semantic search:

• Embeddings only, not code — We index your repository by converting code into mathematical vectors (embeddings). These vectors enable semantic search but cannot be reversed back into source code. Your actual code is never stored at rest on PixelFrame servers.
• On-demand retrieval — When generating a PR, we fetch the relevant code directly from GitHub at that moment. Code is used only during the AI generation process and is not persisted.
• Repository isolation — Database-level filtering ensures one user cannot access another user's data. Each search is scoped to your repository only.
• Secret sanitization — Before indexing, we automatically redact API keys, tokens, passwords, and other sensitive patterns from the text used for embeddings.
• Private key exclusion — Files like .pem, .key, .keystore, and .p12 are never indexed at all.
• GitHub App authentication — We use standard GitHub App OAuth — no personal access tokens required, and you control which repositories we can access.
• OAuth for integrations — Jira, Linear, and Slack connections use industry-standard OAuth flows. We only request the minimum permissions needed.

For more details, see the Security & Privacy section in our documentation.