pre.dev：全自主AI工程师年入50万美金

Getting started on a $500k ARR business

I studied both business and computer science. After school, I spent years as a technical consultant and serial entrepreneur, building projects across fintech, healthcare, social media, crypto, consumer, and enterprise. Before pre.dev became a product, Adam and I were running a consulting firm, scoping and shipping software projects for clients across industries. During that time, we started building internal tooling to automate our own planning and scoping workflow. That internal tool became the seed of what pre.dev is today. For the first few years, we were developing the agent alongside the agency, using every client engagement as a feedback loop. The agency funded the R&D, and the R&D made the agency better. Eventually, we decided to spin out the tool as a standalone product. Now, we're building a full agentic engineer. Not a copilot, not an autocomplete, not a chatbot that generates code snippets. An actual autonomous software engineer that takes a project from idea to deployed, production-ready code. You describe what you want built. Our agent researches the problem, generates a full architecture and roadmap with milestones and user stories, then writes and ships the code autonomously. Task by task, branch by branch, PR by PR. Each task runs in an isolated sandbox, gets type-checked, linted, and visually verified through a headless browser before it ever touches your GitHub repo. It can work for hours or days on a single project without hand-holding. Over 10,000 founders have used the platform — including companies like NVIDIA, and teams backed by YC and Techstars. We also have hundreds of dev agencies using pre.dev for real client projects, which is the strongest signal that the agent actually works on production workloads. We're currently at $500k ARR.

Build what you know

I kept watching the same painful cycle play out. A founder has an idea, spends $50-100K and 3-6 months getting an MVP built, and only then discovers nobody wants it. Or worse, they can't even get started because they can't find a technical co-founder or afford a dev shop. We were living this problem from the other side, too. Running the consulting firm, we saw how much time went into just scoping and estimating projects before a single line of code been written. Discovery calls, architecture documents, back-and-forth on requirements. It was the same process every time, and it felt like something that should be automated. When AI models got good enough in 2023, we realized the bottleneck wasn't code generation. It was planning. Andrej Karpathy talked about the shift from "vibe coding" to "agentic engineering," and that framing captured exactly what we were seeing. Every AI coding tool — Replit, Lovable, Crew, etc. — could spit out code, but they'd all fall apart the moment a project got real. The tools were generating code nobody could trust or ship. Nobody was building an actual engineer. Nobody had the data to make AI plan like a real engineer. Adam and I did. We'd spent years running the consulting firm, scoping and delivering real projects for real clients. We understood how production software actually gets built: the estimation, the architecture decisions, the edge cases that only show up when you're building for paying customers. We realized we could encode all of that into an agent. That's why we decided to do it. And it's the reason our agent is so good — it wasn't built in a vacuum. It was built while we were running a real consulting firm and working with hundreds of dev agencies. We've seen how production projects actually get scoped, estimated, architected, and built. That dataset is what makes our agent plan like a senior engineer who's shipped dozens of products, not like a model that read some docs.

The shift from services to product

With that said, one of our biggest challenges was the transition from consulting firm to product company. For the first few years, we were running both in parallel: building up the agency, serving clients, and developing the agent on the side. There's a moment where you have to decide whether you're a services business that happens to have a product, or a product company. Making that leap was scary because the agency was generating real revenue. But the product had clearly outgrown the consulting business, and trying to do both at full intensity wasn't sustainable.

Shipping in 36 days

We shipped the initial product in 36 days. But it wasn't a cold start. By that time, the planning agent had already been battle-tested on real engagements with real budgets and real constraints for a few years. That's why agencies trusted it immediately. The key technical insight was treating specs like a compiler pass. Instead of going straight from idea to code (which is what most AI tools do and why they break on real projects), we have an intermediate representation. A detailed architecture with nodes, edges, dependencies, and user stories that the coding agents can execute against reliably. There's a reason compilers don't go straight from source to machine code. Same principle. The first version was honestly pretty rough, just the planning piece with AI-generated project specs. But it was immediately useful. We iterated from there: coding agents, GitHub integration, sandbox environments, the visual verification loop, and eventually the full autonomous execution engine. Each layer made the previous one more valuable. The planning engine went from "nice spec doc" to "compiler frontend for an autonomous engineer."

A heavy stack

We use TypeScript, top to bottom. We're building an autonomous engineer, so the stack is heavier than a typical SaaS: Frontend: React 18 with Vite, Redux Toolkit, Radix UI + Tailwind. Backend: Node.js + Express with GraphQL (Apollo Server). Redis for pub/sub and caching. WebSocket subscriptions for real-time updates. Bun as our runtime in production. Database: MongoDB Atlas. It stores the entire graph representation of every project's architecture across the platform. AI layer: This is where it gets fun. We're multi-model: Claude, Gemini, GPT, MiniMax, Qwen, GLM, etc... We also fine tune the models to our own dataset and the respective codebases to make them more accurate and reliable. Agent infrastructure: Kubernetes on Google Cloud. Each coding task runs in an isolated Docker container with its own sandbox. Playwright runs inside for browser-based visual verification. The agent literally screenshots what it built and checks it against acceptance criteria. gRPC handles communication between agent pods and sandboxes. The architecture we're most proud of is the isolated task context system. Instead of dumping an entire codebase into one context window (which is why most AI coding tools choke on bigger projects), we delegate individual tasks to focused agents that only receive the context they need. It's the difference between asking someone to rewrite your whole app versus giving them a clear ticket with the right files attached.

Three-phase growth

We use a SaaS, freemium model. The free tier gives you 100 credits to try the full agent. Then it's $25/mo (Plus), $49/mo (Premium), $199/mo (Pro with Deep Spec, our most detailed autonomous planning mode), and custom Enterprise pricing with unlimited credits and a dedicated solutions engineer. The growth came in clear phases. Phase one: people paying for the planning and spec engine, just the architecture piece. This worked early because our planning agent was genuinely better than anything else out there. It was built on real project data from years of consulting work and agency partnerships, not just generic model outputs. Phase two: we shipped autonomous coding agents, which dramatically expanded the value prop and let us charge more. Phase three (now): the full agentic engineer. Planning, coding, verification, and deployment, all autonomous. That's the Pro and Enterprise tier, and it's where the real expansion revenue lives. People start on the planning tool and upgrade once they realize the agent can actually ship their features. Here's what I've learned about pricing: Don't compete on being cheap. We're not trying to be the cheapest AI coding tool. We're replacing $50k+ of development work. When a founder can validate and build an idea for $49/mo instead of spending months and tens of thousands of dollars, the ROI is absurd. Price on value, not on what competitors charge for token access.

Scrappy and manual

Early on, we grew through pure outbound sales. We targeted dev agencies and technical teams on Clutch.co, specifically ones with high project minimums, which signaled they'd value a tool that multiplies throughput. We'd get them on calls, show the product live, and let the agent speak for itself. Scrappy and manual, but it taught us everything about what our best customers actually needed. Content has been a compounding channel. Writing about the problems we're solving brings in founders and developers who've felt those exact frustrations firsthand. Every blog post is basically us explaining why we built what we built. It's not thought leadership for vanity. It's documentation of our worldview, and it attracts people who share it. Word of mouth has been the biggest driver lately. When someone ships a real product using pre.dev — not a demo, but an actual product — they talk about it. Especially agencies that are using the agent across multiple client projects. That kind of validation spreads fast. Partnerships with Polkadot, Mana Tech Miami, and Google for Startups have also put us in front of concentrated groups of builders. And they have other benefits too. Getting accepted into the Google for Startups Cloud Program, for example, was a game-changer for infrastructure costs. Running an autonomous engineer at scale on Kubernetes is expensive. Each task spins up its own container with a full dev environment and a headless browser. That partnership gave us room to scale without hemorrhaging cash.

Pick a niche and get people to pay

Here's my advice: Get people to pay. Not "I'd totally pay for this," but actually pull out the credit card. That's the only validation that matters. We used short-term promo codes to lower friction while still requiring payment, and it instantly separated real demand from polite interest. Pick a niche that's embarrassingly specific. We didn't go after "everyone who builds software." We started with a very specific customer profile and expanded from there. That specificity made our outreach, product, and positioning dramatically sharper. You can always broaden later, but you can't un-dilute a vague positioning. Ship in weeks, not months. We built and launched in 36 days. The first version was rough. But it was in front of paying customers, and every week it got better based on real usage instead of hypothetical requirements. Don't hide behind product work. A lot of technical founders avoid sales because it's uncomfortable. But those early conversations teach you more than any amount of building in isolation. Get on calls. Be genuinely curious about how your customers work today. The product insights you get from sales conversations are worth more than any analytics dashboard. And build something you actually use. We use pre.dev to build pre.dev every single day. That's not a cute founder story. It's our most important product feedback mechanism. If your own tool frustrates you, you'll fix it faster than any customer ticket could make you.

What's next?

We're pushing the agent to handle increasingly complex, long-running engineering work. Right now, it can work autonomously for hours or days on a project. I want that to be weeks. An agent that owns an entire product lifecycle, not just individual tasks. Planning, building, testing, iterating based on user feedback, shipping updates. A real engineering teammate that doesn't need to be managed. We're expanding the integration ecosystem to work with any external service. The goal is: plug in your existing codebase, your APIs, your design system, whatever tools you already use, and the agent just works within your world. No migration, no lock-in, no starting from scratch. Enterprise is growing fast. Bigger companies want agentic engineering for internal tools, rapid prototyping, and innovation labs. They're not looking for another copilot. They want autonomous execution with proper verification and code review workflows. That's exactly what we built. Longer term, I think we're heading toward a world where the default way to build software is to describe what you want and let an agentic engineer handle it, with humans doing code review, strategic decisions, and the genuinely creative architecture work. The $50K MVP is already dead. The next thing to go is the idea that you need a full engineering team just to test whether an idea is worth pursuing.