The professional design tool for agent-era products Join our discord: https://teapawt.net/t.co/bHzobx26DE
Joined August 2024
- Tweets211
- Following4
- Followers1.2K
- Likes672
Brilliant retweeted
no prompt, just told fable 5.2 to go wild on the canvas... OH BOY 🧵
Brilliant retweeted
why I'm so bullish on AI powered canvases
3 minutes, here's the new spec for the agent to reskin kitze's app against
enjoy: brilliant.design/ami/kitze-t…
Brilliant retweeted
I mean, yes. but also -
Brilliant retweeted
crazy fact: we’re shipping way faster than linear
2 humans + an army of thousands of agents
People keep asking how companies like Ramp, Linear, and Anthropic ship so much software with agents.
There is no new SDLC or secret set of tools. The tools are increasingly available to everyone. You can build your own, use Linear, Claude, or whatever works.
The bigger difference is ambition. These companies encourage their teams to build more, experiment more, and let agents do more of the work. That's the main different between "AI native" or not. You try to use the technology to the max.
But don't get there by adopting a tool. You get there by changing what you believe your teams are capable of.
So in the very simplest way:
- let agents build
- make it easier and faster to contribute
- increase the ambition of what your teams attempt.
In practice, that means things like:
- Standardize around cloud agents. Most of our code (5M lines last quater) is now written in Linear with our Linear cloud coding agent. Cloud sandboxes make standardizing the system and environment easier for everyone and enables faster contributions
- Linear agent (with code access and cloud agent) operates in Slack too. If there is a discussion or someone notices a problem just say "@linear fix this" (decrease the time from something noticed to fixed)
- As bugs, errors etc arrive in Linear, send them to Triage, and have Loop to auto-investigate (connect to tools like Sentry, Datadog), and write a fix
- Let designers, PMs, non-technical people contribute code where useful. If they notice a problem, tell them they can submit a fix. If they want to try something, ask them to build a prototype.
- Set up code review agent and system to make sure PRs are safe to merge.
- Run security as an automation, have agents constantly try to find security issues in your codebase, as they find, send it to a coding agent
- Instead of working on issue level, increase ambition, make a whole project, ask the agent to ask questions, investigate code base, create issues and have the agent work on the whole project at once. Set up goals like "give me proof that what you build works". All our PRs now come with screenshots and videos and preview build you can
- Bring customer feedback to the system like Linear, and make it available for your team. At Linear every project now starts with 10-500 customer notes that influence the direction of the work, and which customers we should ask to test the solution first.
- Set up Loops/automations to constantly update reference documents for agents, like product area/code owners so work can be routed to right humans
Then what is left is how do you set direction for your teams (initiatives, projects they should work on) and how do you review results (better code review, Linear does it with Guided Reviews), how you maintain quality/cohesion which is not a new problem either.
Basically most of the problems you always had remain, but the execution bit is now more and more solved.
At @linear we can help with automation, cloud agents, and code review, customer feedback and planning bits.
But we can't change your mindset or how your company operates.
If your company is still spending energy debating jira workflow steps, you're probably solving the wrong problems.
Brilliant retweeted
I find Figma's AI approach super interesting
From what is public, they finetune 27-70B param models on synthetic data and have various evals to get small models fluent in editing Figma's data model
Where this is smart, problematic and where it breaks:
VERY smart:
1. Much cheaper for them to generate. comperable open models cost between $0.1-0.9 for Input vs Opus 5.5's $4.0, and output $0.2-0.8 vs Opus 5.5's $20. Price ofc even lower when not using third party models.
2. Small models are improving. Same model size, new model, fine tuned -> better results
3. Figma's synthtic data gen & evals will improve, driving even better results
Problematic:
1. SOTA models are moving FAST. Figma's fine tuned models are frozen at its training date. Even with rapidly trying to keep up, they'll also be lagging.
2. Fine tuning teaches taste and figma's data model, HOWEVER - it does not add intelligence. So it can match frontier models on narrow editing evals, but general reasoning is capped to the base model
3. following up on 2 - from what is public, *they don't only use small models*. So I'm assuming the underlying edits are either done by a small model or by 3rd party likely frontier models with extensive system prompting.
4. So on more complex tasks you're either using a model with limited intelligence or a potentially frontier model which is much more expensive for them (and you) and isn't fine tuned for editing figma data model
Where it breaks:
Llama 3.3 70B has 128K context window. Even if you get a small model with 1M+ context windows in the future: again, you're limited on intelligence and reasoning
Why this matters:
Even highly compressed, Figma's design data is still very verbose. Try copying a design in figma (cmd + c) and asking your agent how large the underlying data is
For reference, the size you get is BINARY. The plain text version is several times larger.
So why is this in the "breaks" category?
1. Design system data is verbose and specific (design token names, hex values etc)
2. Real world projects have hundreds of components and variants. Some coming from team libraries or other sources
3. Image feedback (post edit, feeding the model what the state looks like) is very powerful. But also more tokens.
Even if you've got a SOTA model trying to distill huge amounts of design data into a smaller, simpler format, optimizing for a 70B model to reason about - it's a 27-70B param model making the actual changes with a 27-70B param intelligence
Will be very interesting to see how it changes with time and with user feedback. Personally, I'm fascinated since this is truly a hard engineering problem.
on the one hand, an expensive, SOTA model that is extremely smart but can't speak figma
On the other hand, a small model that is fluent in Figma but can't reason over a certain level of complexity
It's also a fascinating business problem:
Their financial report shows AI is cutting into their margins already, using the above architecture (assuming it's somewhat accurate).
Even If frontier models are suddenly fluent and able to edit figma files freely - that cost eats their margins and either rolls over to customers or hurts their reports and forcast and the company's valuation
Disclaimer: There are many ways to potentially solve this, and I'm sure the underlying architecture is way more sophisticated to make up for the issues above.
The @figma agent can now edit and generate vector paths, work with style references.
In this example, I create some alternate arrows and apply a path trim with color cycle animation.
Brilliant retweeted
btw the website is using our latest (unannounced) brilliant MOTION
all website animations are one or two prompts in Brilliant
Brilliant retweeted
Paper, Wonder, MagicPath, Claude design, Google Stitch, Doop, and thousands of others are all making this brutal mistake
Take this from a software architect who went through several iterations of building a general purpose canvas from scratch on several architectures
Very easy mistake to make. Just look at the *entire industry*
usually, by the time you realize it - you're already months or years into squeezing every millisecond of performance
I'm asked daily if I'm not worried about the competition.
The answer is a confident no. Not because they aren't super talented engineers or founders with incredible vision.
It's a brutal tech stack choice mistake.
even with our hyper optimizing rust GPU-native rendering engine, on some real world projects we start hitting performance limits
dom-based canvases don't even realize what bottlenecks are down the line once they're able to optimize the (in retrospect) very small scale issues they're currently facing
Brilliant retweeted
Huge respect to the Figma team. But I don’t see how this would work with their current data model and architecture
Even with a super fine tuned model that speaks Figma data model as fluently as it does html/css, the sheer amount of tokens needed to represent a design, especially for large real-world products constraints the model’s ability to reason about the big picture.
It’s true in general but even more so for a design tool where image feedback has tremendous gains (but also consumes large amounts of context)
Of course they can context manage to help the model reason better but that invalidates the cache which is more expensive and that rolls over to customers
A design-focused chat, similar to a code/product-focused chat is usually a long, continuous chat. We see this from usage patterns inside Brilliant
This means that every AI edit costs many tokens, and has potentially image feedback as well
Don’t believe me? Try copying (cmd+c) a design in Figma and ask your agent to read the size of what was copied to your clipboard
That content is compressed. Even uncompressed: it’s binary. The plain text version, a version the agent can reason about is several times larger
You can play with all of these designs here:
brilliant.design/lior/upload…
