The thing that was bothering us

If you're not a developer, building a Frontify extension is effectively impossible. You need to know how to scaffold a project, authenticate correctly, navigate our GraphQL API, and understand the difference between an app surface and a custom block. These prerequisites stack up to a huge barrier.

That bothered us. The people with the clearest view of a problem — the designers, the brand managers, the people working inside the product every day — are exactly the ones who can't build a solution for it. All that potential just sits there.

The idea

We're building an AI-powered development companion for Frontify extensions. You run a single command, and an AI assistant takes over the orientation work. It knows the ecosystem, apps, blocks, and themes, and guides you through building in plain language, using tools like Cursor or Claude Code as the underlying engine.

Think of it as having an expert developer who already knows everything about Frontify's extension platform, so you can start building without learning it first.

What we actually built

The core of what we built is a skill architecture, a structured set of instructions that AI coding agents can load on demand. Each skill is a focused, self-contained file covering one part of the Frontify extension ecosystem.

In total, we shipped around 10 skills:

• An orchestrator that runs a short discovery dialogue — what are you building, which surface, and where are you in the project — and routes you to the right skill
• Type skills for the three extension types: apps, custom blocks, and themes
• Auth skills for apps and integrations separately, because auth works differently depending on what you're building‍
• Shared resource skills for the GraphQL API, media processing, the Fondue design system, and deployment
• A bundled CLI (command line interface) so the agent can scaffold, validate, and deploy without a separate install step

The skills load lazily; the agent only pulls in what it needs as the work progresses, which keeps it focused instead of overwhelmed.

To put it to the test, we built several extensions during the week: multiple iterations of a QR code creator app, a new table block, a bulk asset metadata exporter that outputs to CSV, and, because why not, Doom running inside a Frontify app. The moment that made the week feel worthwhile was getting a working app scaffolded in under 15 minutes, with minimal back-and-forth and very little correction. The range of what we shipped suggests the skill architecture holds across different extension types and levels of complexity.

Getting started

The repo is live at github.com/Frontify/buildforfrontify. Clone it, and point your AI coding agent at the skill directory:

git clone https://github.com/Frontify/buildforfrontify.git

From there, the orchestrator takes over. It will ask you a few short questions — what you want to build, which surface, and where you are in the process — and load the relevant skills from there. The setup instructions and prerequisites are in the README. You don't need to know which skills exist or in what order to use them. That's the point.

What's still open

Since the hackathon, we’ve run the skills against more extension types, and the architecture has held up. Apps, custom blocks, and themes all build reliably from the same starting point, and the gaps we’ve found have been small enough to fix within the skills themselves. That gives us a solid baseline to keep building on.

It also keeps bringing us back to a bigger question: what if you didn’t need an external coding tool at all? Imagine building an extension directly inside Frontify, with no terminal, no IDE, and no setup. The people closest to the problem could build the solution right where they already work. We haven’t committed to that direction, but the more we test, the more the idea seems worth exploring.

Curious about anything we’re building (beyond Sparks)? We’d love to hear from you.