Supabase AI Assistant vs Together AI Inference Stack 2.0

“The primitive here is clear: natural-language-to-Postgres-RLS-policy translation, embedded directly in Studio with zero additional config. The DX bet is that the right moment to generate an RLS policy is when you're already looking at the schema, not when you've switched to a docs tab or an external chat window — and that bet is correct. RLS is genuinely one of those areas where developers make subtle, security-breaking mistakes not because they're careless but because the mental model for row-level predicates doesn't map cleanly to SQL syntax. The moment of truth is whether the generated policies are actually correct for edge cases like authenticated vs. anon roles, and if Supabase has trained this on their own policy library, that's a real advantage over asking GPT-4 the same question cold. My only flag: schema suggestions being 'suggestions' rather than automated migrations means you still own the migration file, which is correct but worth noting — this doesn't automate away the dangerous part, just the hard-to-think-about part.”

“The primitive is clean: a routing layer that accepts a policy object instead of a model name, and resolves the right model at inference time. That's the right DX bet — you put the complexity in a declarative config, not in your application logic, which means you're not writing if-cost-lt-x-use-model-y spaghetti in your own codebase. The moment of truth is whether the policy API is expressive enough to handle edge cases like 'fast for < 50 tokens, quality for > 200' — the blog post gestures at this but the actual parameter surface needs hands-on testing. This is not something a weekend script replaces; real multi-model routing with fallback, retries, and cost accounting is at least three weeks of glue code. Shipping because the abstraction is placed at the right layer, not dressed up as a platform you have to adopt wholesale.”

“The category is AI-assisted database tooling, and the direct competitors are Cursor with a Postgres connection, GitHub Copilot in a SQL file, and just pasting your schema into Claude. Supabase wins specifically on context — the assistant knows your actual schema, your existing policies, and the Supabase-specific conventions around auth.uid() and storage policies, which a generic LLM doesn't have without prompt engineering. The scenario where this breaks is anything involving complex multi-tenant RLS with dynamic role hierarchies — the kind of policy a senior backend engineer would spend two hours whiteboarding will not come out correct on the first generation, and a developer who trusts it without auditing will have a security hole. What kills this in 12 months: nothing, actually — this is the rare case where the right outcome is that this becomes table-stakes infrastructure in every database IDE and Supabase just keeps it. They own the distribution.”

“Direct competitors are OpenRouter and the routing layer baked into LiteLLM — both of which have been doing model routing longer and have wider model catalogs. Together's differentiation is that they own the inference infrastructure underneath, meaning the routing isn't just load-balancing between third-party APIs — they can actually optimize at the hardware level, which is a real and defensible edge. The scenario where this breaks: enterprise customers with strict data residency or model-pinning requirements, where 'let the router decide' is politically untenable regardless of how good the policy engine is. What kills this in 12 months isn't a competitor — it's OpenAI and Anthropic shipping their own tiered quality/speed endpoints natively, which removes the need to route between providers entirely. Still shipping because the infra ownership angle is real, not marketing.”

“The job-to-be-done is sharp and singular: help developers write correct, non-trivial Postgres security policies without becoming RLS experts first. That's a job with genuine friction — I've watched competent engineers spend 45 minutes on a policy that should have taken 5, specifically because the feedback loop between writing a policy and testing it under different roles is slow. Onboarding here is essentially zero: you're already in Studio, you describe what you want in plain English, you get SQL. The opinion baked into this product is that security configuration should live in the same surface as schema design, not in a separate security tab or external tooling — and that's the right opinion. The gap I'd flag is that 'schema normalization suggestions' is a much vaguer feature than RLS generation and needs more product definition: does it detect missing foreign keys, redundant columns, or full 3NF violations? That distinction matters for whether it's useful or just noise.”

“The thesis Supabase is betting on: in 2-3 years, the primary interface for database configuration is natural language embedded in the IDE surface, not SQL written from memory — and the team that owns the IDE owns the configuration layer. That's a falsifiable claim: it requires LLM accuracy on security-critical SQL to reach a threshold where developers trust generation over authoring, which is a higher bar than it is for, say, boilerplate component code. The second-order effect that's underappreciated: if RLS policy generation becomes reliable, it shifts the security responsibility in small teams from 'we need a backend engineer who knows Postgres internals' to 'we need someone who can describe access rules in English' — that's a genuine expansion of who can build secure multi-tenant applications. Supabase is on-time to this trend, not early: Prisma, PlanetScale, and Neon are all moving toward intent-based database management. The infrastructure state where this wins is Supabase Studio as the default database IDE for the next generation of full-stack developers who never learned raw SQL.”

“The thesis is specific and falsifiable: within 3 years, production AI applications will be heterogeneous-model by default, and hardcoding a single model will look as naive as hardcoding a single database server. That bet is well-supported by the trajectory of model proliferation — we went from 2 viable frontier models to dozens in 18 months, and the trend is acceleration, not consolidation. The second-order effect that matters here isn't cost savings — it's that routing intelligence becomes the new moat layer: whoever owns the policy engine that decides which model runs owns the relationship with the developer, not the model provider. Together is early on this trend, not on-time, which means they have 12-18 months to build enough workflow stickiness before the hyperscalers ship routing as a commodity feature. If this works, the infrastructure state is: Together is the BGP of AI inference — invisible, critical, and deeply embedded in every production stack.”

“The buyer is a platform engineering team or AI infrastructure lead at a company already spending five figures monthly on inference — this isn't for hobbyists, it's for people who have already felt the pain of over-spending on GPT-4 for tasks that GPT-4o-mini handles fine. The pricing scales with usage which is correct alignment, though the real risk is that cost-optimization features commoditize the value prop: if Together routes you to cheaper models efficiently, they're optimizing their own revenue downward, which creates a structural tension. The moat is the combination of owned infrastructure plus the routing intelligence trained on real workload data — that's a real data flywheel if they execute. The business survives a 10x model cost drop because the value is operational simplicity, not the raw tokens; that's the right place to be.”