Phos4
Year
2025
Industry
Developer Tools · Data & Analytics
North Star
Make SQL feel like thinking, not typing.
The hardest problem on this engagement wasn't code. It was velocity.
Mozart's engineers were capable. They were also slow because they had no leverage. Nobody on the team had used agentic development in a disciplined way, and there was no infrastructure to support it. The first phase was trust: showing the team that AI could accelerate their work without sacrificing rigor, then building the harnesses that made the acceleration repeatable.
I stayed embedded with the team, running pair sessions, designing review workflows, building prompt architecture, and setting quality gates for AI-generated code. The goal from the beginning was self-sufficiency. The team needed to sustain the velocity after I left.
Metric | Before | After |
|---|---|---|
-------- | -------- | ------- |
Commits per week | ~50 | 300+ (peak: 570) |
Lines changed per week | 5,000 to 10,000 | 30,000 to 80,000 |
Contributors active per week | Sparse | Full team |
The stacked commit chart tells the real story. The acceleration wasn't one person going faster. It was the entire team producing at a different level. That happened because the training was about patterns and judgment rather than dependency on any individual tool or person.
Every visual decision on Phos4 came back to one question: what does this feel like at hour six?
The product is built for engineers who still want to work with their hands. The kind of people who fix old electronics instead of replacing them. They use AI, but they also want to fiddle with the query, feel the data, and understand what's happening underneath. That sensibility drove everything.
I workshopped the design direction with the CEO around the idea of warmth. The SQL IDE category is dominated by cold, clinical interfaces, and we wanted something different. We landed on a Gruvbox-inspired palette with amber accents and warm tones that reduce eye strain over long sessions. The palette signals something the market hadn't articulated: a tool designed for the experience of actually living inside it all day.
The theming engine supports ten color palettes across light and dark modes with a dynamic CSS variable system and localStorage caching for instant switches. Each engineer tunes the environment to feel like theirs. That's ergonomics, not preference.
Zen Mode and Focus Mode are first-class interaction paradigms rather than features buried in a settings menu. Focus mode dims inactive panels so your attention stays on the active workspace. Zen mode strips everything except the query and the results. If the tool is fighting you at hour six, the tool is wrong.
Most SQL editors display your code. Phos4's Monaco integration understands the structure of what you're writing and surfaces that understanding through the interface.
I built the Monaco theming system with 18 themes, semantic token mapping, and CSS variable integration, then went deep on dialect-aware intelligence. The editor supports Snowflake, BigQuery, Databricks, and Redshift with behavior that goes well beyond syntax highlighting.
CTE-aware code folding uses visual decorations that reflect the query's logical structure. A join profiler provides predicate analysis and join type detection. SQL function autocomplete works with per-dialect snippet support. Jinja template support handles dbt workflows. And a baseline diff mode lets you compare query versions side by side.
The editorial decision behind all of this was that the intelligence should be ambient. You shouldn't have to invoke a feature to benefit from it. The editor should quietly understand what you're doing and make the right information available at the right moment.
I designed and built Phos4's first agentic AI system, and this is where the consulting and the product work converged. I was teaching the team to use AI as a development methodology while simultaneously building AI into the product they were shipping.
The design principle was that the AI should function like a crew rather than a single assistant. One agent writes SQL, another reviews it, a third pressure-tests the data. The AI doesn't replace the engineer's judgment. It gives them more surface area to apply that judgment.
The architecture integrates multiple LLM providers via OpenRouter with streaming insights delivered over server-sent events. A tool routing framework dispatches requests to specialized handlers for dbt commands, git operations, schema lookups, and query analysis. Conversation history includes context chips so users can steer the AI's attention toward specific tables, schemas, or prior queries. Auto-analysis proactively surfaces insights about query results, and model selection lets users choose their preferred provider.
The same philosophy we used for the team's development workflow carried through to the product: AI-assisted, human-directed.
Phos4 is a production IDE. The frontend comprises 285 React components across 33 feature categories, built to support ten tightly integrated capabilities without feeling bolted together.
The architecture runs on React 19 and TypeScript over Vite. There are 66 reusable UI primitives built on Radix and shadcn/ui with Tailwind CSS 4, including 13 button variants and 5 input variants, every one documented in Storybook. Nine React Context providers handle cross-cutting concerns like auth, file management, warehouse metadata, focus mode, and user preferences. Ten Redux slices manage domain logic across the editor state, query execution, AG Grid configuration, formatting, profiler, schema browser, and the AI assistant. TanStack Query handles data fetching and AG Grid Enterprise handles data display. Testing runs through Vitest for unit tests, Playwright for end-to-end, and Storybook for visual regression.
I should note what others built. The VP of Frontend Engineering built the DuckDB WASM integration, which handles client-side SQL processing with Apache Arrow and Parquet and eliminates server round-trips. Other engineers built backend services, the profiler pipeline, and warehouse connection infrastructure.
I built the design, the frontend architecture, and the AI integration layer. The team built on top of it.
The outcome I keep coming back to is the velocity chart. An entire team went from grinding at 50 commits a week to sustaining 300 or more. The architecture gave them something solid to build on, and the AI training gave them the speed to actually use it.
A production SQL IDE. Architecture, interaction design, AI integration, and team transformation, shipped and live.
