You can build a tiny project on a weekend, forget about it, then watch it quietly grow into a $34,000/month machine with almost no ongoing work. That is exactly what happened with Cursor Directory, a small site that started as a flight idea and turned into a serious business.
In this breakdown, you will see how developer and founder Pontus Abrahamsson went from bored on a plane to running a directory that:
- Was coded in about 3 hours
- Reaches millions of visitors
- Runs at 99.8% profit margin
- Takes only about 3 hours per month to maintain
You will learn how the idea came together, how it was built so fast, what tools power it, why directories still work in 2025, and what you can take from this story for your own projects.
If you want to see the product while you read, you can visit the live site at Cursor Directory.
The Wild Origin Story Of Cursor Directory
Cursor Directory is built by Pontus and his best friend and co-founder, Victor. They spend most of their time bootstrapping their main startup, Midday, and they build side projects for fun, in public, and often open source.
One weekend project changed everything.
On a three hour flight to France, Pontus downloaded a bunch of technical videos about Cursor, the AI code editor. While watching, he started to notice a pattern in how people used "rules" with Cursor. Rules help shape how Cursor behaves and how it writes code. There was clear interest in these rules, but no central place to find and share them.
By the time the plane landed, he knew there was a gap.
Here are the quick facts about Cursor Directory:
- Built in a weekend, with about 3 hours of coding for the initial version
- Grew to 49,000 registered users
- Reached 2.2 million unique visitors since launch
- Has operational costs under $500/month
- Runs at about 99.8% gross margin
- Is fully open source and managed via GitHub
- Requires about 3 hours per month to maintain
Today, the site is a go-to resource for Cursor users and developers exploring AI workflows. You can see what they built at Cursor Directory.
How The Idea Sparked On A Flight
That flight to France was the turning point.
Pontus had downloaded Cursor content and noticed that creators kept talking about rules. Yet there was no single hub for them. Everything was scattered across:
- Obscure GitHub gists
- Random forum threads
- One-off posts that were hard to find later
The "aha" moment looked roughly like this:
- He binge-watched Cursor related videos on the flight.
- He saw a repeated pattern: people sharing and refining rules.
- He realized there was no dedicated directory for these rules.
It was mind blowing that such a strong pattern had no central home.
If you are not familiar with Cursor, it is an AI-assisted code editor built to make coding faster with smart autocomplete and AI pair programming. That context made the gap even clearer. Developers wanted better rules, better setups, better ways to customize Cursor. They just had no organized place for it.
So, the second he landed and arrived at his Airbnb, he called Victor.
“We need to build a directory for Cursor rules.”
They decided to do it right away, instead of tossing it on a long list of "someday" ideas.
What Cursor Directory Actually Does
At its core, Cursor Directory is a simple concept: it is a directory site. A directory helps people discover things they care about. In this case, those things are rules and related resources for Cursor.
Cursor Directory helps developers:
- Explore new rule ideas
- Find rules that match their stack or workflow
- Copy and paste rules directly into their own Cursor setup
- Share their own rules with the community
Over time, it grew beyond a bare rule list into a small ecosystem around the Cursor community.
Some of the key features include:
- Browsing, filtering, and searching rules by tags and popularity
- Viewing popular and official rules
- Copying rules straight into your Cursor editor
- User accounts so developers can submit and manage their own rules
- Upvotes so the best rules rise to the top
- A job board where companies can pay to post and promote roles
- Special listings for MCPs (extensions that expand Cursor's abilities)
All of this is wrapped in a clean, sharp design that feels like a natural fit for developers.
How It Makes Money
For such a small site, the business model is straightforward and smart.
Cursor Directory earns revenue from:
- Paid job listings: Companies can pay to have their jobs listed on the site so developers who use Cursor can discover them.
- Featured MCP listings: When MCPs (which extend Cursor's features) were introduced, Cursor Directory added a searchable MCP section and allowed creators to pay to feature their MCPs. This brought a second wave of growth.
- High efficiency, low cost: With hosting and tools at roughly $500 per month, the gross margin lands around 99.8%.
There is also a clever tool on the site that lets developers upload their package.json and generate Cursor rules tailored to their tech stack. This does two things:
- It helps developers who are not sure where to start with rules.
- It strengthens the site's position as a practical, everyday utility.
A Quick Tour Of Cursor Directory
If you open Cursor Directory, you will see a very simple setup.
You get:
- A list of rules with titles and tags
- Filters so you can narrow down by category or topic
- Clear labels for popular, official, and featured entries
- A search bar to jump directly to what you need
Once you create an account, you can:
- Submit your own rules
- Vote on rules you like
- Share useful setups with other developers
- Take part in a community that constantly tweaks and improves Cursor usage
There is also the jobs area, where developers can spot new roles and companies can reach a focused audience.
If you want to follow what Pontus is building next, he shares a lot of his work in public on X at @pontusab.
From Idea To MVP In 3 Hours
The build story is where things get crazy.
Pontus landed in France, got to his Airbnb, called Victor, and got to work. There was no long planning phase, no polished spec, no months of delay.
Here is what happened step by step:
- Call the co-founder: As soon as he landed, he told Victor, "We need to build a directory for Cursor rules."
- Design while coding: Victor opened Figma and started designing the interface. At the same time, Pontus created a new project using Next.js.
- Hardcode the first data: Pontus created a simple JSON file with a handful of rules he had found online. No database, no complex backend.
- Deploy fast: Within about 30 minutes, they had something running on Vercel that they could click around on.
- Buy the domain: They grabbed a strong domain related to Cursor Directory. A good domain helped with trust and shareability.
- Ship the MVP: In roughly 3 hours, they had a live site, a basic design, and enough content to show the concept.
From there, they kept iterating in small steps while still focusing mainly on their main startup, Midday.
A big reason this worked is that Pontus and Victor have worked together for years. They already share a design language, coding habits, and a clear split of responsibilities. When you know your co-founder well, you can move very fast with very little back and forth.
Their approach to shipping fast:
- Do not sit on obvious ideas.
- Use tools you already know.
- Be okay with imperfect design at first.
- Launch, then refine in public.
That mindset is also what Starter Story encourages with programs like Starter Story Build, which focus on shipping real apps using AI tools instead of staying stuck in tutorials.
The Lean Tech Stack Behind Cursor Directory
Pontus has a simple rule for picking tools: use what you already know and what lets you ship without dealing with servers and heavy setup.
Here is the core stack they used for Cursor Directory.
Core Tools And Why They Used Them
| Tool | Purpose | Why They Chose It |
|---|---|---|
| Next.js | Web app framework | Familiar, fast to build with, great for React and routing |
| TypeScript | Type-safe JavaScript | Catch bugs early and keep codebase maintainable |
| Shadcn UI | Components for the front end | Reusable components, consistent design |
| Resend | Transactional email | Simple email sending with little setup |
| OpenPanel | Analytics | Lightweight analytics to track visitors and usage |
| GitHub | Version control and open source | Hosts code, handles pull requests from the community |
| Vercel | Hosting and deployment | One click deploy, no servers to manage |
| Polar | Payments and billing | Merchant of record, especially helpful for EU based companies |
| Cursor | Coding assistant | Used to write code faster with AI |
| Notion | Product and project management | Simple way to track tasks and ideas |
A few key points from their stack:
- No servers to manage: Everything runs on modern platforms that handle infrastructure.
- Low friction: They can focus on product and users, not devops.
- AI in the workflow: They actively use Cursor as a coding tool to speed up development.
All in, the tools and hosting cost about $525 per month, which is tiny compared to the revenue.
How Cursor Directory Went Viral
Building a product fast is one thing. Getting users is another. Cursor Directory did both.
From day one, Pontus and Victor built in public. They share their projects, wins, and code on X. That meant they already had a small but relevant audience of developers who cared about the same things.
Here is how they launched and grew the directory:
- Posted on X: Pontus shared Cursor Directory on X when it launched. One of the posts hit about 1 million impressions. They kept posting progress, updates, and insights.
- Open source code: Making the project open source on GitHub helped it feel like a community resource rather than a closed product. Developers could contribute rules, report issues, or send pull requests.
- Hacker News: They submitted Cursor Directory to Hacker News and it made the front page. That sent a big wave of traffic and gave the project more credibility.
- YouTube coverage: Several YouTubers in the developer and AI space picked it up and featured it in videos. This brought a more steady stream of users.
- Sharing knowledge: They did not just share the link, they shared insights about Cursor, rules, and how they think about building. That kept interest going long after the initial spike.
Pontus described the initial response as instantly took off, I have never seen something like that before.
The audience match was perfect:
- Developers already using Cursor
- Curious about rules and customization
- Active on X, Hacker News, and YouTube
Combine that with a clean design and a clear use case, and people were happy to share it.
Design As A Hidden Advantage
One thing that stands out when you visit Cursor Directory is how polished it feels for such a small project. The typography, spacing, dark theme, and layout all feel intentional.
Pontus credits a simple formula and Victor's skill as a designer.
His design approach looks like this:
- Keep it simple: Strip away anything that does not help the user do the core job.
- Borrow from what you love: Find websites you really like, study them, and learn from their patterns. Not copy, but pull ideas for layout, mood, and tone.
- Reuse components: They already had a design system and components from previous projects. That meant faster builds and visual consistency.
- Stay consistent: Pick a style and stick with it across pages and projects.
He also points out something important about today’s AI-heavy web. With AI tools making it easy to churn out sites that all look alike, design is more important than ever. Good design is now a key way to stand out.
A few quick design tips from their example:
- Focus on one primary action per page.
- Use clear contrast so content is easy to scan.
- Let typography and spacing do a lot of the design work.
- Do not overload the screen with options.
If you want to see an example of clean, focused design in a developer product, Cursor Directory is a good reference.
Are Directories Really Still Working In 2025?
Many people assume directories are outdated. A few years ago, they were everywhere. Then interest seemed to fade and many died off.
Pontus hears this a lot: "Aren't directories dead?"
His answer is simple: no, not if you build the right one for the right audience.
Directories still work when:
- They solve a timeless problem, like finding something specific quickly.
- They focus on a real, active niche, not a vague broad topic.
- They arrive at the right time, when the audience is searching for clarity.
In an AI-driven world, developers are hungry for examples, rules, prompts, and extensions. Tools like Cursor make people ask, "How do I set this up the right way? What are other smart people doing?"
That is a perfect use case for a directory.
Why Cursor Directory works:
- It solves a clear problem: find good Cursor rules in one place.
- It focuses on a very specific audience: Cursor users and developers.
- It landed at the right moment: when Cursor interest was climbing and MCPs appeared.
- It stays useful every day: you can actually copy rules and improve your own setup.
Many directories fail because they never find this fit. They are too broad, too shallow, or not attached to real behavior.
Cursor Directory shows that niche directories can still crush it, even in 2025.
Lessons You Can Steal For Your Own Project
You may never build a Cursor directory, but you can copy a lot of what made this project work.
Pontus’s core advice is simple: start.
Here are some practical takeaways:
- Act on fresh ideas
When you see a clear gap (like rules scattered across random posts), do not sit on it for months. Move while the idea is still exciting. - Build with tools you already know
Pontus stuck with Next.js, TypeScript, and his usual stack. That let him build in hours, not weeks. - Ship before it feels perfect
The first version was a basic list with hardcoded JSON. It was enough to show the concept and gather interest. - Build in public
Sharing progress and code on X and GitHub brought in early adopters and contributors. It also gave them a built-in launch pad. - Aim for tiny maintenance
The business works partly because it only needs 3 hours a month. Think about models and tools that let you keep costs and workload low. - Treat "failure" as learning
As Pontus puts it, when you build something, the worst thing that can happen is you learn. One project leads to another, one insight leads to the next.
Conclusion: Small Projects, Big Outcomes
The story of Cursor Directory is proof that a simple idea, executed fast, can outperform huge, overplanned projects.
A bored founder on a flight, a three hour coding session, a clean design, and a focused niche turned into:
- $34,000/month in revenue
- 2.2 million visitors
- A 99.8% margin business that runs in a few hours per month
You do not need a perfect plan. You need a real problem, a clear audience, tools you can move fast with, and the willingness to ship.
The next time you spot a gap in your day to day work, ask yourself what would happen if you built the smallest possible version this week. Not someday. Now.
Thank you for reading. If this story pushes you to start something, that might be the most valuable part of the whole directory: the reminder that starting is where everything changes.
0 Comments