Own Your Code, Control Your Complexity

Most starter kits have a dirty secret: they're designed to impress you, not serve you. They ship with every integration under the sun, and when you realize you only need half of it, you're stuck reverse-engineering someone else's abstractions to figure out what's safe to delete.

Eden Stack is different. You get the full source code — every line, every integration, every pattern. And because the entire codebase is designed for agentic development, you have something no other starter kit gives you: an AI collaborator that understands the architecture and can reshape it to fit your exact needs.

The Spectrum of Need

Not every project needs the same thing. That's obvious. What's less obvious is that most starter kits force you into an all-or-nothing proposition.

Eden Stack doesn't. It gives you a spectrum:

"I just need a web app and an API"

Great. Tell Claude:

I only need the web app and API layer. Remove Inngest, Stripe,
Resend, PostHog, and Sentry integrations. Keep TanStack Start,
Elysia, Drizzle, Neon, and Better Auth.

Claude knows the architecture. It'll remove the unused integrations, clean up the imports, delete the config files, and update the environment variables. What's left is a clean, minimal codebase with type-safe routing, a Bun-native API, and a database — nothing else.

You own the code. There's no hidden framework layer, no "core" package you can't touch, no subscription that gates which features you get to use. Delete what you don't need. It's yours.

"I need the whole package"

Then the whole package is there. Auth, payments, email, background jobs, analytics, error tracking, AI pipelines — 60+ primitives across 7 domains, pre-wired and working together. Every integration follows the same four-layer pattern (schema, API, hooks, UI), so adding features is predictable whether you write them yourself or let Claude do it.

The point isn't that Eden Stack has a lot of features. The point is that every feature is real code in your repository that you can read, modify, and delete.

"I need to swap out a tool"

This is where ownership really shines.

Maybe your company is an Azure shop and Neon Serverless Postgres doesn't fit your infrastructure. Maybe you're in a regulated industry and need to self-host everything. Maybe you just prefer a different tool.

With Eden Stack, you don't file a feature request or wait for a plugin. You tell Claude what you need:

I need to replace Neon Serverless Postgres with Azure Database
for PostgreSQL. Update the Drizzle config, connection setup,
and environment variables. Keep the same schema and migrations.

Claude has access to up-to-date documentation through MCP servers. It searches the docs for your target tool, understands the migration path, and makes the changes. The architecture stays the same — Drizzle still talks to Postgres, your schema doesn't change, your API routes don't change. Only the connection layer moves.

The Enterprise Scenario

Here's a real example that illustrates why code ownership matters more than feature lists.

Eden Stack uses Inngest for background jobs. Inngest is a durable execution platform — it handles event-driven workflows with step-level retries, checkpointing, and automatic failure recovery. It's excellent for SaaS products and startups.

But what if you're building inside an enterprise AWS environment? Your infrastructure team has standardized on AWS services. They won't approve a third-party execution platform, no matter how good the developer experience is.

Here's the thing: there is no single AWS product that does what Inngest does. Inngest combines event routing, durable workflows, job queuing, compute, and scheduling into one developer experience. To replicate that on AWS, you need to stitch together multiple services:

That's five services replacing one. The complexity is real. But here's the key insight: the complexity is yours to manage, not yours to discover.

With Eden Stack, you tell Claude:

I need to replace Inngest with AWS-native services. Use EventBridge
for event routing, Step Functions for durable workflows, SQS for
queuing, and Lambda for execution. Migrate the existing Inngest
functions in src/lib/jobs/ to Step Functions state machines.
Keep the same event-driven patterns.

Claude reads the existing Inngest functions, understands the step-level patterns, and translates them into Step Functions definitions with the equivalent retry and checkpoint semantics. It sets up the EventBridge rules to route events to the right workflows. It creates the Lambda handlers.

Is it more code than the Inngest version? Yes. Is it more complex? Yes. But it's your complexity, running on your infrastructure, under your control. And every line of it is in your repository, readable and modifiable.

Why This Matters

The software industry has oscillated between two extremes for decades:

Extreme 1: Build everything from scratch. Maximum control, maximum effort. You own every line but spend months on infrastructure before writing a single feature.

Extreme 2: Use a platform that abstracts everything away. Ship fast, but the moment you need something the platform doesn't support, you're stuck. When the platform changes pricing or shuts down, you're scrambling.

Eden Stack occupies a third position: start with everything, then shape it to fit.

If that sounds familiar, it should. It's the same philosophy that made shadcn/ui one of the most influential projects in modern web development.

The shadcn Parallel

Before shadcn/ui, you had two choices for UI components: install a component library like Material UI or Chakra and live within its constraints, or build everything from scratch. shadcn changed the game by saying: here are beautifully designed components with sensible defaults — but they live in your codebase, not in node_modules. Copy them in, own them, customize them however you want.

No wrapper components to fight. No theme overrides to debug. No breaking changes when the library updates. Just real code in your project that you control completely.

Eden Stack applies the same thinking to the entire full-stack architecture.

Traditional starter kits are like traditional component libraries — you install them, you're bound by their abstractions, and when you outgrow them, you're stuck. Eden Stack is the shadcn approach applied to your whole stack: auth, payments, email, background jobs, analytics, observability — all living as real code in your repository with sensible defaults and room for full customization.

The difference is scope. shadcn gives you ownership of your UI layer. Eden Stack gives you ownership of your entire application — from the database schema to the API routes to the background jobs to the deployment config.

You begin with a production-ready codebase that handles the common patterns — auth, payments, email, jobs, analytics, observability. Then you use Claude to trim, swap, and extend until the codebase matches your exact requirements.

The architecture is designed for this. Every integration is isolated in src/lib/, connected through clean interfaces. Removing Stripe doesn't break auth. Swapping Neon doesn't affect your API routes. Adding a new service follows the same pattern as the existing ones.

Claude as Your Architecture Partner

This isn't just about having source code access. Plenty of open-source projects give you that. The difference is that Eden Stack's codebase is optimized for AI-assisted modification.

Every pattern is consistent. Every integration follows the same structure. Claude skills encode the institutional knowledge of how things connect. MCP servers provide up-to-date documentation for any tool you might want to swap in.

When you say "replace X with Y," Claude doesn't guess. It reads the existing implementation, searches the target tool's documentation, and makes the migration. You review the changes, and you ship.

This is what ownership looks like in 2026: full source code, consistent patterns, and an AI collaborator that can reshape the codebase faster than you can read the migration guide.

The Bottom Line

Eden Stack isn't a black box that does things for you. It's a well-architected codebase that does things with you.

• Need less? Remove what you don't need.
• Need more? The patterns are there to follow.
• Need different? Describe the change and let Claude handle the migration.

You own every line. You control the complexity. And you have an AI partner that understands the architecture well enough to help you shape it into exactly what your project requires.

That's the beauty of owning your code.