48 Hours, 60 Seconds
ZAIGOOD was a real Delaware C-Corp I dissolved after years of compliance drag. This week I rebuilt it in 48 hours with an autonomous AI build loop, tried to submit it to Product Hunt for a YC interview slot, and missed the deadline by exactly 60 seconds.
The Death
ZAIGOOD wasn't just a Delaware C-Corp. It was an old name.
The first version was my experimental venture studio from roughly 2012 to 2016 — a container for ideas, prototypes, false starts, and the general conviction that I was going to build my own way out of the systems I was living inside. The second version was a Delaware C-Corp I incorporated in 2020, when the name came back attached to a real entity and a real compliance surface.
Same name. Different era. Same underlying problem: the shell of the thing kept demanding energy before the thing itself had earned it.
It generated exactly $0 in revenue. It still cost me money every year just to keep it alive: registered agent fees, annual reports, franchise tax, the occasional penalty when the calendar slipped and the state kept moving anyway. Delaware charges you for the privilege of existing on paper even if you've never run a transaction, never had a customer, never done anything except keep the shell alive.
I dissolved it in 2024. Not because the market wasn't there. Not because the idea failed. Because the legal apparatus required to maintain the shell of a company consumed more attention than the company itself.
The bureaucracy killed it. Not product-market fit. Paperwork.
That's the thing nobody tells you when you incorporate: you're not just starting a company. You're enrolling yourself in a compliance system that runs on your calendar whether you're building or not. Miss your Delaware annual report and you get voided. Miss your franchise tax and the state suspends you. Miss your registered agent renewal and you lose legal standing. And all of this is paperwork — not building, not selling, not shipping — just maintenance fees on the option to exist.
I paid those fees for four years. Then I stopped.
The Resurrection
On March 11, Matthew Berman posted a simpler question: who is building products and services for agents? He mentioned @agentmail and here.now and asked who else should be on the list.
I replied. And in the moment of writing the reply, I realized I had two things at once: the origin story (ZAIGOOD the dead C-Corp) and the product (everything that would have prevented the death). The name wasn't just a scar. It was a brief.
The "for agents" angle clicked differently than the founder-pain angle. Founders need this, yes. But agents are the accelerant. If software is going to help people start, run, and monitor companies, it needs to understand the compliance surface those companies live inside. An agent that needs to file an 83(b) election, manage a registered agent relationship, compare jurisdictions, check the status of an entity before doing business with it, or keep a founder from sleepwalking into penalties — that agent needs an API. There's no Stripe for legal compliance. That's the gap.
The tweet that snapped the thing back into focus was this reply to Matthew Berman:
I’m shipping an end-to-end incorporation (and monitoring/compliance) platform for agents
The decision to build wasn't a decision. It was recognizing a thing that already existed and pointing at it.
48 Hours
I run Forgeloop — an autonomous AI build loop on my VM. The pattern: git-driven task routing, agents build against a spec, proof-of-work verified, loop. I've written about it before. The abstraction level when it's working correctly is: you write what needs to exist, the loop builds it, you review the output.
What "48 hours" meant in practice for ZAIGOOD was this:
Entity Intelligence layer: Playwright-based scrapers for Delaware and California entity lookup. DE queries the Division of Corporations. CA hits the Secretary of State API. The scrapers return normalized entity objects: name, status, formation date, registered agent, good standing flag. They run as child processes — Playwright can't bundle into Nitro's ESM build cleanly, so each scrape is a subprocess invocation with a 45-second timeout. That took an iteration to figure out; the first implementation tried to bundle in-process and hit require is not defined in ES module scope errors buried four layers deep in the Playwright core.
Compliance rules engine: YAML-based. Each entity type gets a compliance calendar spec — Delaware C-Corp, Delaware LLC, California LLC, etc. Annual reports, franchise tax deadlines, 83(b) election windows, state filing requirements. The engine ingests an entity's formation date and type, outputs a sorted array of deadlines with days-until calculations and status flags. The YAML structure means you can add jurisdictions without touching application code.
Health check API: The public endpoint. Input: company name, state. Output: entity status from the state scraper + compliance calendar for the entity type + any outstanding obligations. The free tier was intentionally the first wedge: run checks immediately, hit the wall later.
Compliance calendar + reminders: Not just a static list of dates. There's a real calendar surface, ICS export, Google Calendar handoff, reminder subscription flows, filing-service hooks, and the beginning of a system that turns compliance from ambient dread into an actual operating surface.
Compare + map: One of the most obvious founder questions is not just “am I compliant?” but “where should I be?” The product already has compare and map surfaces because jurisdiction choice is part of the problem, not a separate product category.
Contract review: AI-powered document analysis. Upload a contract, get back: risk flags, plain-English explanations of complex provisions, and a benchmark against what's market-standard for early-stage startup agreements.
Pricing, auth, and the gate: There are already pricing tiers, gated checks, auth plumbing, and Stripe checkout wiring in the product. Which means this wasn't just a demo page with a search box. It was already trying to become a real SaaS system.
What's it like to run a build like this? The work is not code-writing. It's decision-making about architecture, then reviewing outputs against the spec. The agents execute. Your job is to catch when the execution diverges from the intent — which is different work than implementation, and harder in some ways because the implementation happens faster than you can form expectations about it.
There's a point in a build like this where you run out of decisions. The agents are executing. The builds are running. You're reading test output and diff reviews and deployment logs. The bottleneck has shifted from "can we build this" to "is this what I actually want built." That's the right bottleneck to have — it's a better problem than the alternative — but it still requires presence.
By around 9 PM on March 11, the thing was already real enough to count: the entity scrapers were returning live data, the compliance engine was generating calendars, the health check was working, and the landing page was up. The remaining hours were the difference between “real product” and “launch-ready product.”
60 Seconds
The Product Hunt deadline was March 11, 11:59 PM PT. Product Hunt had posted the bait themselves:
We're teaming up with @ycombinator to get builders to launch. Schedule your launch for tomorrow, tag "YC application." and @aaron_epstein will review launches. Top ones could get a YC interview + potential funding. 👇
YC interview energy, artificial urgency, launch tomorrow, maybe someone important will look at your thing. I wasn't seriously planning a launch. Then I saw the post and did what everyone does when the timeline manufactures a countdown around your ego: I treated a fictional deadline like an absolute one.
The war plan became: get the full PH listing ready and submit with buffer. Name, tagline, description, topics, screenshots, first comment.
I missed by exactly 60 seconds.
The screenshot of the "deadline passed" modal has a timestamp. One minute. Not "missed by a few hours because I didn't plan ahead." Missed by one minute because the form took longer than the buffer and because, realistically, I'm a new dad with a couple real working hours left in the day — not some 20-year-old in a hacker house optimizing sleep debt into launch throughput.
The post I fired off afterward was a reply to that original Product Hunt / YC announcement:
missed the deadline by exactly 1min and landed on lucky Fri 13 and no YC
The Friday thing is a Product Hunt scheduling artifact — miss midnight and you drift into the next day's traffic pattern, which is traditionally weaker. The fake urgency was still fake. The 60 seconds were still real.
The equanimity was real and also completely coexisted with the frustration. Both things were true simultaneously. The product existed, but another 24 hours of build mattered. At 11:59 PM the Stripe integration was still placeholder keys, the auth gate wasn't wired, and several screenshots were still demo-mode. By the next morning the site was serving real health checks on zaigood.com, the landing page had been ported cleanly, the service survived reboot, the OG assets were ready, and the thing looked like a company instead of a midnight argument.
The 60 seconds didn't kill the thing. They just meant the thing launched on its own terms instead of on PH's schedule.
What It Is Now
zaigood.com is live.
The health check works. Enter a company name and state, get back a real compliance snapshot: current standing, filing status, deadline calendar. Delaware and California are live. The scraper architecture is built to extend — adding a new state is a new subprocess handler and a YAML compliance spec. The next obvious expansions are the same ones every entity operator eventually runs into: more states, Companies House, cross-border entity maps, the full lifecycle instead of a point check.
The thesis is unchanged from the Product Hunt copy: ZAIGOOD is the Stripe of legal compliance. Stripe didn't invent payments — they built the API layer that made payments programmable. Rather than operating like a law firm, ZAIGOOD is trying to become the intelligence layer that makes entity management programmable.
For founders, that means: stop tracking compliance deadlines in a spreadsheet, stop getting surprised by franchise tax bills, stop pulling your hair out trying to file your annual report. The AI handles 80% of legal ops; human escalation handles the 20% that actually requires judgment.
For agents, it means something different. The agent economy is real. Agents incorporate entities, manage corporate structures, engage contracts on behalf of principals. Those agents need infrastructure that matches their operating rhythm — API-first, deterministic, comprehensive. The health check API is the first endpoint of that layer. The compliance calendar and contract review are second. The compare and map surfaces make the jurisdiction question legible. The full entity management stack is the roadmap.
There are 5 million new US business entity applications per year. That's a record high. The compliance surface on each of those entities starts accruing from day one. Most of them have no system — just email reminders from registered agents and panic when something lapses.
The market is the compliance surface of every entity that has ever existed. We're starting with the ones that are actively drowning.
The Pattern
What the ZAIGOOD build demonstrates about building in 2026 — and what I still don't think gets said clearly enough — is this:
The constraint isn't capacity. The loop produces code faster than any individual can design for. The constraint is decision clarity — knowing precisely what you want built, in what order, for what purpose. Execution has been commoditized. Direction hasn't.
This changes the calculus on starting something. The 48-hour build wasn't a stunt so much as the natural consequence of entering the loop with a clear spec. The spec existed because the pain was personal and four years old. The clarity came from the scar tissue.
The inverse is also true: you can spin the loop indefinitely on a vague brief and produce enormous quantities of code that doesn't add up to a product. The loop amplifies direction. It doesn't substitute for it.
Which means the most important question for any build isn't "can we build this" — it's "do we know exactly what we're building and why." ZAIGOOD the C-Corp spent four years giving me the answer to the why. The loop took 48 hours once the why was clear.
The 60 seconds don't change any of that. The product shipped. The clock is still running.
Entity health check: zaigood.com
Build loop: forgeloop.zakelfassi.com
Subscribe to the systems briefings
Practical diagnostics for products, teams, and institutions navigating AI-driven change.
Subscribe to the systems briefings. Practical diagnostics for products, teams, and institutions navigating AI-driven change. — Occasional briefs that connect agentic AI deployments, organizational design, and geopolitical coordination. No filler - only the signal operators need.
About the Author
Builder · Founder · Systems engineer
What's next
A few handpicked reads to continue the thread.
- →8 min read
The Harness
OpenAI shipped Symphony — a daemon that monitors your issue tracker and deploys agents to close tickets. The README says it works best in codebases that have adopted harness engineering. So you click the link. Then you find the Ralph citation. Then it gets interesting.
forgeloop - →6 min read
The Plumber Lives Inside the House
A friend sent three questions about agents over WhatsApp. Where do they live? What's the interface? Where do they report back? The answers reveal a mental model most people are missing — and why the plumber has to live inside the house.
overhead - →5 min read
SkDD: Skills-Driven Development
I accidentally named it SDD in October. Spec-Driven Development claimed that acronym. So: SkDD — the methodology I have been running in production since a git init at 1:54 AM.
skills-driven-development