AI-native development: how we build software with Pixel AI™
- Written by
Alexandra Bigotte de Almeida- Published
Key takeaways
- In software development, Pixel AI™ brings together shared context, versioned skills, agentic workflows, guardrails, and a senior product, design, and engineering team that signs the work.
- Agents set the speed, but quality comes from deciding in advance where people step in: every pull request gets a risk tier that sets how deep the review goes, and another developer always has the last review.
- Agents are only as good as what they can see, so we connect your code, specs, and design system once and give each agent only the access its job needs.
- Skills are playbooks our team writes and reviews, one for every step from spec to release, and they go stale as a codebase changes, so auditing them is part of the job.
- When we start with your team, the first weeks go into your goal, a shared squad, and the process from idea to release, and your team learns to run it day to day.
- Writing code is only part of shipping. Retros run on Pixel AI™ too, so what slowed one cycle down becomes a fix to the process for the next.
When a CTO or a CPO asks how we use AI, the easy answer is a list of tools. It's also the least useful one, because everyone has the same tools now. What actually differs between teams is the system around them: what the agents know, which standards they follow, and who checks their work before it reaches your users.
That system, for us, has a name: Pixel AI™. It's how we work whether we're building your product or changing how your teams build. This piece looks at how it applies to AI-native development: what's in it, how a piece of work moves through it, and what changes in your project when we start.
What is Pixel AI™?
Pixel AI™ is our AI software development framework: how we design, build, and ship software, and a result of becoming an AI-native company ourselves. It has five layers (context, skills, agentic workflows, guardrails, and team) and one outcome: the product your users touch.
It's proven on every product we ship. Work gets from idea to launched feature 50% faster, with the same team and the same review bar.
We built it because tools alone weren't the answer, for us or for anyone else. In the Stack Overflow 2025 Developer Survey, 66% of developers said their biggest frustration is AI solutions that are "almost right, but not quite" (opens in a new tab), and 46% distrust the accuracy of AI tools (opens in a new tab). Google's DORA research reaches the same place from another angle: AI "doesn't fix a team; it amplifies what's already there" (opens in a new tab). Without a system around them, agents spread inconsistency as fast as they spread good practice.
The five layers of the Pixel AI™ framework
Each layer answers one question a product or engineering leader should ask any partner using AI on their product.
Layer | What it is | The question it answers |
|---|---|---|
Context | Your code, design system, specs, and product data, connected once | Does the agent know my product, or the internet average? |
Skills | Our craft written down as versioned playbooks | Whose standards does the work follow? |
Agentic workflows | Repeatable work run end to end, from triage to pull request | Where does the speed come from? |
Guardrails | Tests, previews, security checks, and human review on every change | What stops speed from turning into risk? |
Team | Product, design, and engineering in one senior team | Who steers the agents and signs the work? |
The first two layers are where most of the difference lives, so they're worth a closer look.
Context: agents work on your reality
An agent can only be as good as what it can see. Anthropic's engineering team describes context as a finite resource with diminishing marginal returns (opens in a new tab): giving an agent everything is nearly as bad as giving it nothing. So the work is context engineering: choosing what each agent needs and connecting it properly.
Pixel AI™ plugs into the tools teams already use, from GitHub, Linear, and Figma to Notion, Slack, and the main coding agents, so agents can cite the spec, the design, and the decision behind a change. Much of that wiring runs on the Model Context Protocol, an open-source standard for connecting AI applications to external systems (opens in a new tab). Each agent gets least-privilege access, only what its job needs, which matters more than it sounds when the codebase belongs to you.
Skills: our craft, versioned
A skill is a playbook an agent loads when it needs it. In Anthropic's definition, skills are folders that include instructions, scripts, and resources (opens in a new tab). Ours hold how we've designed and built products since 2014: how we question a spec, how we plan a change, what a finished pull request looks like. We have more than 40, one for every step from spec to release, and our team writes, reviews, and runs them every day.
Skills also go stale. A codebase moves, files get renamed, conventions change, and a playbook that was right in March can quietly point at the wrong place by June. So auditing skills against the codebase is a skill of its own, with every drift reported back to the person who owns that skill.
How a piece of work moves through Pixel AI™
AI-native development with Pixel AI™ connects discovery, delivery, and learning in one loop, with people deciding what moves forward. There's a skill for every step, and the work and its risk decide which ones run.
- Idea. We challenge scope, users, and edge cases before anyone builds, test risky assumptions in a throwaway branch, and make proposed flows tangible through prototypes checked in the browser. Skills such as
/grilling,/spike, and/prototypestructure that work. - Build. We turn each ticket into a plan with phases, checkpoints, and risks. To write it, research agents can read the code and the specs in parallel, for example. Then we build one phase at a time, with the agent rereading the plan before every step and writing tests alongside the code, and walk every acceptance criterion in the running app.
/plan,/execute, and/verifyrun those steps. Agents take the work as far as a pull request, and another developer reviews it before it merges. - Learn. After release, we check what changed for users, for example by comparing error rates and key funnels with the week before, and draft the next ticket with the evidence. We compare what the cycle planned with what shipped, turn the lessons into actions with owners, and keep the playbooks honest.
/watch-release,/retro, and/audit-skillsrun that loop.
None of these replace a conversation. They make sure the conversation starts from the right information.
Take the onboarding example from the demos on our Pixel AI™ page. Before anyone plans the work, /grilling asks the questions a sharp colleague would ask. Does an invited teammate count as a user? What happens if someone leaves the flow halfway through? Who gets to skip the welcome tour? A product manager answers each one, every answer goes back into the spec, and the open risks are flagged before planning starts. The agent finds the gaps. The person decides what the product should do.
The same demos show who runs them: a product manager runs /grilling, a staff product designer runs /plan, a QA tester runs /verify, and our CEO runs /audit-skills.
The guardrails: where people step in
Agents move faster than any team can review, and they can drift. The guardrails decide, in advance, where people step in and how closely they look.
- Every change goes through several reviews, and the last one is always human. The developer who built it checks it first. Agents review it next: one sizes the risk, and another runs an adversarial review at that depth and leaves its findings inline. Then another developer reviews it and decides whether it merges. Agents never approve.
- Every pull request gets a risk tier. The tier sets how much attention the review needs, so the riskiest changes get the closest read.
- Rules in CI/CD decide what merges. They set who approves and what gets blocked, so you stay in control of what ships however much code agents write.
- Reviews arrive as readable reports. Reviewers decide in minutes instead of digging through diffs.
- Tests come with the code, not after it. Verification runs the real app on every change and hands failures back to the build instead of fixing them itself.
- The project's rules live in the repository. Agents read its standards, such as accessibility and interaction rules, before they build, and the tests run again when the pull request opens.
- Unhappy paths get mapped before release. Built-in tools find and simulate the errors a user might run into.
- Design alternatives stay visible. Teams compare explorations and trade-offs directly on the prototype.
Every change gets a human review. What the tiers decide is where the deepest attention goes, and we'd rather put a senior engineer's full attention on the risky change than spread it evenly across every change. That's the trade the guardrails make. Bruno Teles, a staff product designer on our team, describes the effect on design work: "Design reviews got shorter, not lighter."
Running the delivery, not only writing the code
Writing code is only part of shipping software. Running the delivery around it is work too, and it runs on Pixel AI™ as well. /retro looks past single tickets to what slowed the team down, so the fix goes into the process. In the demo on our Pixel AI™ page, three pull requests came back from /verify for the same missing empty states, so empty states went into the plan checklist.
Pixel AI™ also builds the agents and automations our operations teams use, and the guardrails come with it: on our own website, for example, a content change an agent makes in the CMS stays a draft until a person reviews and approves it, and QA still tests it before it's done.
What changes in your project when we start with Pixel AI™
The first weeks look different from a traditional kickoff, because we set up the framework before we build on it. Getting a team running on Pixel AI™ takes two to six weeks from kickoff, fitted to how you work. Here's what happens, in order.
- We start from your goal. You share your product goals, and we assess where your team stands with AI so we know where to begin.
- We assemble one squad. Depending on the work, that could be a product manager, a designer, and an engineer from our side, your engineers and engineering lead from yours, and agents, all plugged into your context. Anyone in your team can talk directly with anyone in ours.
- We set the process. The pipeline from idea to release, who does what and who signs off, and skills written around your stack. Your team learns to run it day to day.
- We ship, with the same checks every time. Releases start soon after kickoff and go through the guardrails above.
The framework is the same whether we build and evolve your product with AI Product Modernization, prove one idea first in an AI Pilot Sprint, or bring it into how your own teams work through AI-Native Enablement. If your teams adopt it, they keep the workflows, practices, and tools when we're done.
What Pixel AI™ won't do for you
A framework is easy to oversell, so it's worth being clear about its limits.
It won't turn a vague goal into a clear one. The /grilling step exists because unclear problems are expensive, and agents make unclear problems expensive faster. It won't replace judgment either. While we were building a website, an agent proposed handling reduced-motion settings by pausing every animation and removing the play button. It looked tidy, and it was wrong: those animations are content, so the right call was to start them paused and let people press play. The agent didn't make that call. One of our design engineers did. Agents can draft the plan, the code, and the review notes, but the call on whether something is good enough to ship stays with a person who's accountable for it. And it won't make a company AI-native by itself. Bruno Teixeira, our CEO, wrote about why adding AI isn't the same as becoming AI-native, and that's a leadership decision before it's a tooling one.
Why the engine matters more than the model
Models will keep getting better, and every team will have access to the same ones. What doesn't come in the box is the context about your product, the playbooks that encode how good work gets done, and the decisions about where people step in. That's what we've built, and it's what we bring to every product we work on. So whether you're choosing a partner or changing how your own teams build, ask about the engine before you ask about the model. You can watch ours at work on Pixel AI™, our AI software development framework.
Frequently asked questions
Pixel AI™ is the AI software development framework Pixelmatters uses to design, build, and ship software, and a result of becoming an AI-native company ourselves. It combines five layers: context about your product, versioned skills, agentic workflows, guardrails on every change, and a senior team that steers the agents and owns the outcome.
You get Pixel AI™ through a Pixelmatters engagement rather than as a standalone license. Either we build your product with it, or we help your own teams adopt it. In the second case, your teams keep the workflows, practices, and tools set up around your stack when the engagement ends.
An AI development framework should cover more than which coding assistant a team uses. At minimum it needs a way to give agents the right context, written standards for agents to follow, clear rules for where people review and approve, and checks on every change. Without those, AI speeds up inconsistency as much as good work.
People are. With Pixel AI™, agents review every pull request first, and another developer always reviews and approves it before it merges. A risk tier sets how deep that review goes, and rules in CI/CD decide what merges and who approves it. Agents plan, draft, and test, but a senior team steers them and signs the work that ships.
No. The first step is assessing where your team stands with AI, from early readiness to fully AI-native, so we know where to start. Teams early on get more of the setup and training. Teams further along usually plug the framework into the tools and workflows they already have.
AI-native development means the process itself was designed around agents: what they know, which steps they run, and where people step in. Using AI coding tools means adding assistants to a process that stayed the same. The first changes how a team works. The second mostly changes how fast one step goes.
Written by

Alexandra Bigotte de Almeida
Chief of Staff