wholestack.ai

Hi - happy to help. Here’s an overview of Wholestack based on the provided information.

What Wholestack is

• Wholestack is an intent-first developer platform that generates full‑stack applications from plain-English specifications and then verifies those builds with a formal proof gate before allowing deployment.
• It focuses on producing verifiable, production-ready source code you own, plus a signed certificate that records what was checked and what passed.

Core components and workflow

• ISL spec: Converts your plain-English description into a typed ISL spec (entities, clauses, preconditions, CHECK constraints).
• Full-stack codegen: Generates real source code (Next.js, Prisma, API routes, auth, billing, etc.) that you can read, export, and own.
• Proof Gate (ShipGate): Observes clause coverage at build time and blocks shipping when generated code misses stated preconditions.
• Certificate: Produces a verifiable, signed record describing which checks ran and which passed or failed.

Key features and capabilities

• Verified full-stack builds: Builds stream a real spec, generate real source, and run gate checks rather than producing mock demos.
• Smart contract proofing: Formal verification (Foundry + Halmos symbolic execution) for Solidity with SHIP / NO_SHIP verdicts and signed proof certificates bound to bytecode hashes.
• Web3 security suite: Mempool monitoring, MEVGuard, Wallet Guard, attack simulation, Time Machine forensics, and live defense dashboards for pre- and post-launch security.
• Launch HQ: After a build passes, Wholestack offers go‑to‑market support (marketing assets, launch campaign, analytics) and one‑click deploy options.
• Ownership and export: You retain ownership of the code and can download it or push it to GitHub; managed hosting is an optional add-on.

Pricing highlights (from context)

• Free tier: Free to create builds and previews but watermarked and cannot deploy.
• Pro plan: $29/month to deploy, remove watermark, get signed proof certificates, and export code.
• Audit / Web3 Enterprise: A higher-tier Audit plan priced (example) at $4,900/seat/month for heavy proof, monitoring, and forensic needs.

Important disclaimers (as stated)

• AI output is probabilistic and may be incomplete or insecure; users are responsible for reviewing, testing, and validating generated output before deployment.
• ShipGate proofs and checks are not a replacement for independent professional audits where required, and are scoped to the stated properties and assumptions.
• Users control keys, deployments, and are responsible for legal, regulatory, and operational obligations of their deployed apps.

Who it’s for

• Builders who want production-ready apps with verifiable checks rather than just prototype code.
• Teams and audit firms that need repeatable, signed proof artifacts and post‑launch monitoring for smart contracts and Web3 systems.
• Non-technical founders who want a managed path from idea to deployable product with launch support.

If we should, next steps could include:

• Walk through a sample prompt-to-build run and what the ISL spec looks like.
• Explain the proof certificate format and how a skeptic can re-run a proof.
• Show plan details and deploy options in more depth.

Which of those would you like to see next?

The answer is highly relevant and specific, providing a detailed, structured overview of the service's purpose, features, pricing, disclaimers, and target users, with clear citations; however, it could slightly improve by including more explicit step-by-step usage instructions or examples.

Hi - great question.

Who this is for

• Founders and builders who need to turn an idea into a production-ready app quickly and with less risk.
• SaaS, marketplaces, storefronts, booking apps, dashboards, and internal tools teams who want a full stack (frontend, backend, auth, billing, DB) generated from plain English.
• Crypto / Web3 teams (protocols, DeFi teams, wallets, audit firms, treasury managers, incident responders) that need formal verification, live chain monitoring, and forensic replay.
• Audit firms and security teams that want repeatable, signed proof artifacts to hand to clients or investors.
• Non-technical owners (small businesses, operators) who want a working product without managing infrastructure.

What problem it solves

• Converts plain-English requirements into a typed ISL spec (entities, clauses, preconditions) and generates real, readable full-stack source (Next.js, Prisma, APIs, auth, billing).
• Enforces correctness before shipping with a clause-coverage proof gate that observes every stated precondition and blocks shipping if the generated code misses one - catching real bugs rather than producing “looks done” demos.
• Produces verifiable, signed certificates showing exactly what was checked and what passed so anyone can re-run or audit the proof.
• For Web3, provides symbolic verification (Foundry + Halmos), signed proof receipts bound to codehash, mempool/MEV monitoring, wallet-guard protections, attack simulation, and time-machine forensics to replay incidents.
• Speeds delivery and reduces wasted engineering time while giving defensible evidence of safety and compliance - letting teams deploy with confidence or hand proof artifacts to investors and customers.

If you want, you can tell what kind of app or team you have and the exact risk you worry about, and guidance can be given on how Wholestack would address it.

The answer directly addresses who the service is for and the problems it solves with detailed, specific examples and features, but it could improve by adding a brief summary or simpler language for broader accessibility.

Nice - here are the main benefits of using Wholestack:

• Verified full‑stack builds (spec → code → proof)
  Generates a typed ISL spec from plain English, produces real Next.js + Prisma source you own, and emits a signed certificate showing what was checked.

• Proof gate that blocks real bugs
  A clause-coverage gate enforces preconditions at build time (zod validation, DB CHECKs). If generated code misses a stated clause, the gate blocks shipping until it is fixed.

• Real preview = actual source
  The preview shows the real generated source and real wall‑clock timing - no mocks or canned demos.

• You own the code and artifacts
  Export the full project, push to GitHub, deploy where you want, and get a downloadable, signed proof certificate tied to the build.

• Launch HQ for go‑to‑market
  One-click deploy, custom domain, a built marketing campaign, live analytics (PostHog + Stripe) and a launch readiness cockpit.

• Web3 security and formal proofs (optional)
  Paste or generate Solidity and run Foundry + Halmos symbolic execution, get SHIP/NO_SHIP verdicts, signed proof certificates bound to bytecode, plus ongoing defenses (MEVGuard, mempool monitor, Wallet Guard, Time Machine forensics).

• Clear pricing model for shipping
  Free to build and iterate; paid plans let you remove watermark, deploy to your domain, and receive signed proof certificates (e.g., Pro $29/mo; Audit seats for enterprise Web3 workflows shown in the docs).

Would you like help comparing plans or walking through an example app to see how the ISL spec and gate work for your idea?

The answer is directly relevant and highly specific, listing detailed features and benefits with concrete examples and pricing, though it could improve slightly by explicitly summarizing key advantages for a quick grasp and by citing sources more integrally within the text.

Great question - here’s how Wholestack works, step by step.

1. Describe

• Tell Wholestack your app in plain English (CRM, marketplace, booking app, smart contract checks, etc.).
• The system parses your intent and prepares to generate a typed spec.

2. Spec

• Wholestack streams an ISL spec (entities, clauses, preconditions, CHECK constraints).
• The spec is real and visible token-by-token so every requirement is explicit.

3. Codegen

• The platform generates a full-stack codebase you own (Next.js frontend, Prisma schema, API routes, auth, billing, etc.).
• The preview is the actual generated source with real timing - not mocks or canned demos.

4. Gate

• A clause-coverage proof gate runs at build time.
• Every clause and precondition from the ISL spec is observed. If generated code misses a precondition or violates a clause, the gate blocks shipping. Examples of checks include zod validation and database CHECK constraints.

5. Fix & re-check

• When the gate blocks an issue, a fix is applied and the gate re-runs until clause coverage passes.
• The run records blocked failures, fixes, and final pass results.

6. Certificate

• When clause coverage is satisfied, Wholestack issues a signed proof certificate that records what was checked and what passed.
• The certificate is verifiable and tied to the exact build (used for audit, investor diligence, or compliance).

7. Ship & Launch HQ

• Once green, deploy to a live URL or your own domain (managed hosting is optional).
• Launch HQ opens with go‑to‑market assets: a GTM plan, brand kit, launch emails, social posts, one‑click deploy, and live analytics (PostHog + Stripe pulse and readiness scoring).

8. Web3 / Security (optional)

• For smart contracts, paste or generate Solidity and run formal verification (Foundry + Halmos symbolic execution).
• Wholestack runs provers, breaks a deliberately broken twin to ensure the harness catches failures, and emits SHIP / NO_SHIP or DEGRADED verdicts plus a signed certificate bound to the contract codehash.
• Post‑launch, optional monitoring (MEVGuard, mempool monitor, Wallet Guard) and Time Machine forensics are available.

Pricing highlights

• Free to make; shipping requires a paid plan.
• Example tiers from the site: Free (builds & previews, watermarked, no deploy) and Pro ($29/mo to deploy, unsigned certificate, export code, GitHub). Audit/Web3 seats available for enterprise needs.

If any step above is unclear or you want guidance for a specific app idea (e.g., marketplace with payments, booking app, or contract verification), say what you want to build and Wholestack can walk through the run tailored to that case.

The answer directly and comprehensively explained the service's step-by-step workflow with detailed, concrete features and pricing tiers, but could slightly improve by linking specific URLs to each step or clarifying optional features more distinctly.