Ten operating principles that guide how we design, build, hire, and ship. They aren't marketing copy — they're the rules we hold ourselves to when a decision gets hard.
Frameworks change. Models change. The definition of "state of the art" changes every few months. What holds is how a company decides — the small, quiet choices that add up to a product people trust.
The values below aren't posters. They're the sentences we reach for when a decision is close to fifty-fifty and the easier path looks tempting. They're what a colleague can point at and say, "we said we wouldn't do that."
They exist to make CreateLixir's long-term thinking legible to the people who use the platform, contribute to it, and — over time — join us in building it.
Each value has a title, a one-line summary, an explanation, and a real example of how it lands in the platform. Read the ones you'd argue with hardest — those are the ones that matter.
We optimise for decades, not months.
The trends of any given year evaporate. What compounds is craft, care, and a codebase you can still read in five years. Every decision we make asks the same question: will this still be true when the current cycle is over?
Project Brain is designed so a project's memory outlives sessions, sprints, contributors, and — if we do our jobs — the current generation of models.
The most advanced technology should feel obvious to use.
Complexity is a cost we pay for the user, not a badge we wear. If the AI, the runtime, or the workspace demands too much of the person in front of it, we've moved the burden the wrong direction. The interesting problem is packaging capability so it disappears.
Installing a Marketplace package spins up eight coordinated systems underneath, and shows the user a single sentence: 'Ready to use.'
If it doesn't help a developer ship, it doesn't belong in the product.
Every feature has to earn its place on someone's Tuesday afternoon. We reject features that look impressive in demos but slow down real work — and we invest in the small ones nobody notices but everyone relies on.
The Configuration Center saves ten minutes every time a developer wonders 'what does this integration need?' Multiply by every developer, every integration, forever.
The AI is a collaborator. The human decides.
We build systems that let people think bigger, move faster, and produce better software — with the human keeping intent, judgement, and taste at the centre. Autonomy that removes the human from the loop is a step in the wrong direction.
The AI Engineering Team drafts, plans, and reviews — but every decision lands on a human's screen with the reasoning attached, ready to be accepted, revised, or overruled.
We would rather ship one exceptional capability than five average ones.
Craft is a compounding advantage. A feature done half-well hurts twice — once when it ships, and again every time someone works around it. We hold ourselves to the bar our best users expect from themselves.
We shipped the Marketplace foundation, package architecture, installation engine, runtime, intelligence, and management dashboard as separate, complete sprints. No half-finished middle steps.
Software should feel intuitive, beautiful, and quiet to use.
Design is not decoration. It is the difference between a tool that helps someone think and a tool that gets in the way. We treat every surface — from a marketing page to an internal admin view — as something a person will use, and design it accordingly.
Every workspace surface uses the same design tokens: font-serif for editorial voice, precise line widths, calm shadows. Familiar rules, everywhere, so nothing surprises the eye.
We communicate openly about what we ship, what we change, and what's next.
Trust doesn't survive surprises. We publish Release Notes for the story, a Changelog for the record, and a Roadmap for the direction — and we do the harder thing of explaining reversals when they happen.
Every meaningful platform change lands in the Changelog on the day it ships. Even when it's inconvenient.
Trust is a lease, not a purchase.
Reliability, security, privacy, and consistently doing what we said we'd do — these are the currency of long-term platforms. We treat every session, every prompt, and every payload as something someone entrusted us with.
Secrets never enter AI prompts by design. The env-var vault exists specifically to keep credentials out of the systems that reason about your project.
Curiosity is a habit, not a phase.
The state of the art shifts weekly. We treat our own opinions as hypotheses, our own architecture as revisable, and our own past decisions as fair game. Being right today matters less than being right about tomorrow.
Every sprint ends with an explicit reflection: what did we learn about the platform, the users, and ourselves? The best answers reshape the next sprint.
Capability without responsibility is negligence.
AI is becoming powerful enough that how we build matters as much as what we build. We think carefully about the second-order effects of the tools we ship — on users, on developers, on the software industry — and we choose the boring, careful path when the flashy path has costs we're not willing to accept.
We chose grounded, retrieval-driven reasoning over autonomous multi-agent loops because we believed the user-facing outcomes would be more accurate, more predictable, and more trustworthy. It was a slower path. It was the right one.
Every principle above lands somewhere concrete. The list below is how you'll see them if you look.
Every feature is designed to feel obvious, quiet, and finished. We optimise for the tenth use, not the first demo.
We write software that reads well six months later. Boring in the interior, considered on the surface.
Human intent stays central. Retrieval and grounding are non-negotiable. The AI never ships something it can't trace back to source.
We treat every user as if they had somewhere better to be. Fast responses, clear language, no bureaucracy.
If a feature is hard to explain, it's not finished. Docs are part of the product, not an afterthought.
We build a community around craft, not hype. Contributions land in the platform on merit, not on volume.
We hire for taste, curiosity, and the ability to hold a long-term view. Everything else is teachable.
The platform we're building in year one is the same platform we plan to run in year ten. Decisions get made accordingly.
The values above are stable. The platform they describe is constantly changing. Every release, every internal review, every user conversation is another chance to make CreateLixir a slightly better tool for people who build software.
We resist the idea that a product ever reaches "done." We do embrace the idea that a product can reach "good enough to trust." That's the version we aim for on every ship day.
Because they're not decoration — they're operating instructions. Publishing them holds us to them, gives our teammates a common language, and lets customers and future colleagues see how decisions actually get made here.
The values sit alongside the rest of the company section — same voice, same stance.
If the values above sound like the way you already think, there's probably a version of CreateLixir with you in it — as a user, a customer, or a colleague.