Your Shopify store will never make a dollar until you fix this one file

Nobody’s store dies from the product. It dies at “Activate payments.” Building a store is a solved problem now. Turning it into something that can legally take a dollar is the part that still kills stores. That part is finally a file you can write.

It’s late. The store looks unreal. Product page crisp, cart smooth, first ad set queued. You click “Activate payments.” Shopify wants an EIN. Stripe wants a legal entity. Your supplier wants a company name and address. You have none of it. The store that took an afternoon now needs two weeks of paperwork it will probably never get.

That gap is where “dropshipping is dead” actually comes from. The market didn’t kill those stores. The setup did.

Here is the whole thing, start to finish, plus every place a short screen recording will sell it harder than a paragraph.

The visible 20 percent, and the 80 that decides if you get paid

Building the store is the fun, visible part. It is maybe a fifth of what stands between you and revenue. The other four fifths is invisible and boring: a legal entity, a tax ID, payment rails, a funded card, a domain, an inbox, a phone, supplier and ad accounts. Claude Code (or Cursor) nails the visible fifth in an afternoon. Until now, the boring four fifths was all you, by hand.

That is the reframe the whole post rests on. The build was never the moat. The boring half was.

The setup tax, itemized (the part every guide skips)

People say “just start a store” like the store is the work. Here is what actually sits between a finished storefront and a live checkout. None of it is hard. All of it is slow. And it is sequential, so the waits stack.

The itemWhy it blocks youWho usually does itRough waitLLC formationProcessors and suppliers want a real entity, not your nameYou + a formation serviceA few daysEIN (tax ID)Stripe, Shopify, and the bank all ask for itYou, via the IRSDays to weeksBusiness bank accountPayouts land here, not your personal accountYou, at a bankDaysProcessor approvalStripe / Shopify Payments verify the business before going liveYou, waiting on reviewThe one that kills storesDomain + support inboxSupport email on your own domain, not a GmailYou, across two vendorsHours to daysPhone + 2FAVerification and support line for the accountsYou, another signupHoursSupplier / wholesale accountsNet terms and real catalogs need a companyYou, per supplierDaysAd account under the businessMeta and TikTok tie spend to the entityYou, per platformHours to days

Read that list again. Every row is a signup, a verification, and a wait. By the time it is all wired, the trend you were chasing is gone.

The shift: the store’s back half is now code

Naïve is an infrastructure layer that gives your agent a governed, real-world identity. Not a mock. A real US LLC, a real EIN, real payment rails, a real card, a real inbox and number. You declare what the store needs in one file, and the agent provisions it.

You do not even have to write the file by hand. Point your agent at the skill and it writes the config for you:

read https://usenaive.ai/skill.md

Paste that into Cursor or Claude Code, and the agent reads what naïve can do, then generates a naive.config.ts for your store.

Here is what that config looks like for a store. It is small on purpose.

typescript// naive.config.ts import { defineConfig, cloud, agentTemplate, policy } from “@usenaive-sdk/iac”;

export default defineConfig({ project: “aurora-goods”,

// Where the store itself runs infrastructure: { web: cloud.web({ framework: “nextjs”, dir: “.” }), database: cloud.postgres({ name: “orders-db”, size: “serverless” }), },

agentProfiles: { store: agentTemplate({ // The real-world identity behind the storefront identity: { kind: “business”, verify: “kyb”, // Know-your-business check form: “llc”, // Real US LLC formation state: “WY”, // Or your state of choice },

  // Comms the accounts will ask for
  comms: {
    email: { domain: "per-tenant" },   // [email protected]
    phone: { sms: true },              // US number for 2FA + support
  },

  // What the agent is allowed to do, and nothing else
  policy: policy({
    allow: [
      "email",
      "llm",
      "search",
      "phone",
      "formation",          // LLC + EIN filing
      "cards",              // Virtual card for ad spend + tools
    ],
    budget: {
      cap: "$YOUR_CAP",     // Hard monthly ceiling on all spend
      alertAt: 0.8,         // Ping you at 80%
      hard: true,           // Stop at 100%, no overspend
    },
    approvals: [
      { when: "formation.submit", via: "email" },
      { when: "cards.create", via: "email" },
    ],
  }),
}),

}, });

Then you run one command:

bashnaive up

Naïve does not just execute blindly. It builds a plan, shows you exactly what it will do in the real world, and waits for your approval on the parts that matter.

$ naive up

Naïve plan · project aurora-goods

Will create ~ identity.llc Form WY LLC “Aurora Goods LLC” [approval required] ~ identity.ein File SS-4 with the IRS [approval required] ~ comms.email Provision [email protected] ~ comms.phone Provision US number (+1) ~ cards.virtual Issue spend card, cap $YOUR_CAP [approval required] ~ infra.web Deploy Next.js app ~ infra.database Provision serverless Postgres

3 actions need your approval. Sending confirmations to [email protected] …

Waiting for approval ▏

The real-world actions do not fire until you click approve in your inbox. Here is what one of those emails looks like:

Subject: Approve: form Aurora Goods LLC (Wyoming)

Naïve is ready to file your LLC. Nothing has been submitted yet.

Entity Aurora Goods LLC State Wyoming Agent Naïve registered agent Cost Shown at usenaive.ai before you confirm

[ Approve and file ] [ Decline ]

You can revoke this agent’s permissions at any time.

The part that used to take a lawyer and two weeks is now a file your agent writes and one command you approve.

Build it with me: a real run

Enough concept. Here is the actual sequence, with the code, from empty folder to live checkout.

1. Build the store

Let Claude Code do the visible fifth. Be specific about the stack so the payment wiring later is clean.

bash# In Claude Code claude “Build a conversion-focused storefront in Next.js (App Router) + TypeScript.

• Product page, cart, and a checkout that calls Stripe Checkout sessions
• A /api/checkout route to create the session
• A /api/webhooks/stripe route to record paid orders in Postgres
• Mobile-first, fast, email capture on exit intent
• Seed one product: ‘Aurora desk lamp’, warm dimmable, USB-C Write clean, typed code and a .env.example.“

You will get a working store in an afternoon. The two routes that matter for getting paid look like this.

Create the checkout session:

typescript// app/api/checkout/route.ts import { NextRequest, NextResponse } from “next/server”; import Stripe from “stripe”;

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function POST(req: NextRequest) { const { priceId, quantity = 1 } = await req.json();

const session = await stripe.checkout.sessions.create({ mode: “payment”, line_items: [{ price: priceId, quantity }], success_url: ${process.env.SITE_URL}/success?s={CHECKOUT_SESSION_ID}, cancel_url: ${process.env.SITE_URL}/cart, automatic_tax: { enabled: true }, });

return NextResponse.json({ url: session.url }); }

Record the order when Stripe confirms payment:

typescript// app/api/webhooks/stripe/route.ts import { NextRequest, NextResponse } from “next/server”; import Stripe from “stripe”; import { sql } from “@/lib/db”;

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export async function POST(req: NextRequest) { const body = await req.text(); const sig = req.headers.get(“stripe-signature”)!;

let event: Stripe.Event; try { event = stripe.webhooks.constructEvent( body, sig, process.env.STRIPE_WEBHOOK_SECRET! ); } catch (err) { return NextResponse.json({ error: “Bad signature” }, { status: 400 }); }

if (event.type === “checkout.session.completed”) { const s = event.data.object as Stripe.Checkout.Session; await sql insert into orders (stripe_id, email, amount_total, currency, status) values (${s.id}, ${s.customer_details?.email}, ${s.amount_total}, ${s.currency}, 'paid') ; }

return NextResponse.json({ received: true }); }

And the secrets the store needs, kept out of Git:

.env.example

STRIPE_SECRET_KEY=sk_live_… STRIPE_WEBHOOK_SECRET=whsec_… DATABASE_URL=postgres://… SITE_URL=https://auroragoods.com

None of that code can take real money yet. That is the point. The code is done. The company is not.

2. Provision the company

bashnpm install -g @usenaive-sdk/cli naive register –name “Your Name” –email “[email protected]” –password “…” naive init # Or let the agent write naive.config.ts from skill.md naive up # Review the plan, approve the real-world actions

Approve the formation and card emails. The LLC and EIN now process in the background while you keep iterating on the store. You did not stop building.

3. Connect Stripe and Shopify with the EIN

Once the EIN lands and the entity is confirmed:

• Stripe: activate the account as a business, enter the LLC name and EIN, connect the business bank for payouts

• Shopify (if you use it): register the store under the business, same entity details

• Set the support address to your naïve domain inbox

• Put the naïve card on file for platform subscriptions and fees

Point Stripe’s webhook at the route you built:

bashstripe listen –forward-to https://auroragoods.com/api/webhooks/stripe

Copy the whsec_… it prints into STRIPE_WEBHOOK_SECRET

4. Wire the ad accounts

Open Meta, TikTok, and Google ad accounts under the business, funded by the capped card. Because the cap is enforced by naïve, the agent literally cannot overspend, no matter what a campaign does.

5. Launch

Publish the store, point the domain, push the first ad set live. The trend you were chasing is still here, because the paperwork ran in parallel instead of in front of you. You were never blocked at step 2.

An agent with a company card, and why that is not scary

Giving an agent a real card and a real entity sounds reckless until you see the leash. Every grant is scoped, capped, logged, and revocable.

The allow-list means the agent can only touch what you named. The budget is a hard ceiling, not a suggestion. The sensitive moves wait for your email. And everything it does is written to a log you can read:

json[ { “ts”: “14:02”, “action”: “formation.submit”, “result”: “ok”, “by”: “you” }, { “ts”: “14:03”, “action”: “ein.request”, “result”: “queued”, “by”: “agent” }, { “ts”: “14:20”, “action”: “cards.create”, “result”: “ok”, “by”: “you” }, { “ts”: “14:21”, “action”: “card.spend”, “amount”: “$18.00”, “memo”: “Meta ads” }, { “ts”: “14:26”, “action”: “email.send”, “to”: “supplier@…”, “memo”: “Net-30 request” } ]

Pull the agent’s access whenever you want, in one call:

bashnaive revoke –profile store –scope cards # Kill spend instantly naive revoke –profile store –all # Full stop

Scoped, capped, logged, revocable. That is the whole trust model.

The real unlock: one entity, many shots on goal

Here is the part that changes the math for operators, not just for a first store.

Form the company once. Every store after that ships under the same umbrella. No repeat formation, no repeat EIN, no repeat bank setup. The marginal cost of store #2, #3, and #4 on the business side drops to near zero. Test a niche, kill it if it flops, scale it if it hits, all under one entity, each with its own capped card so a bad campaign in one store never touches another.

Adding a store is just another profile in the same config:

typescriptagentProfiles: { petGear: agentTemplate({ /* Shares the entity, own card + $cap / }), homeDecor: agentTemplate({ / Shares the entity, own card + $cap / }), testNiche: agentTemplate({ / Shares the entity, tiny cap, easy to kill */ }), }

One company. Isolated budgets. A portfolio of stores you can spin up in an afternoon each, because the slow part only happened once.

Start tonight

bash# Install the naïve CLI npm install -g @usenaive-sdk/cli

Register (includes free credits to start)

naive register –name “Your Name”
–email “[email protected]”
–password “yourpassword”

Check the connection

naive status

Scaffold the config, or skip this and paste the skill into your agent

naive init

Review the plan, approve the real-world actions, done

naive up

Or hand the whole thing to your agent: paste read https://usenaive.ai/skill.md into Cursor or Claude Code and it writes the config and runs the plan for you.

Full docs: usenaive.ai/docs

Quickstart: usenaive.ai/docs/getting-started/quickstart

The store is already built. Speed was always the moat in ecom, and the slow part is no longer slow. So ship the boring half too, tonight.