DEV Community: Orchid Files

Why localhost doesn't work as OpenAI Base URL in Cursor — and how to fix it

Orchid Files — Tue, 11 Aug 2026 09:20:44 +0000

TL;DR: Cursor doesn't call your OpenAI Base URL from your local machine. It routes every request through its backend servers on api2.cursor.sh, so http://localhost:8082 is unreachable — the chat hangs and your proxy logs stay empty. To connect Ollama, LM Studio, LiteLLM, or a custom subscription proxy, you must expose your local port through a public URL — a Cloudflare tunnel is the simplest way, and it is what the Ungate extension automates.

When I first wrote a local Fastify proxy to connect my Claude subscription to Cursor, the setup felt trivial: start the server on port 8082, open Cursor Settings → Models → Override OpenAI Base URL, paste http://localhost:8082/v1, and hit save. I typed a prompt into chat, hit Enter, and watched the status indicator spin forever.

I opened terminal logs expecting to see incoming HTTP requests. Nothing. I ran tcpdump on my loopback interface — zero packets from Cursor.

I spent an hour double-checking port bindings and firewall rules before realizing the issue wasn't in my code. It is in how Cursor is built.

How Cursor actually routes OpenAI Base URL requests

Unlike VS Code extensions, Aider, or Continue.dev — which send LLM API calls directly from your local Node process — Cursor processes chat and agent context on its own remote servers (api2.cursor.sh).

When you select a model and send a message, the request path is:

Cursor UI
   ↓
Cursor's cloud backend
   ↓
Override OpenAI Base URL
   ↓
LLM Provider

Because the third step originates from Cursor's cloud backend over the public internet, http://localhost:8082/v1 resolves to the backend server's own loopback interface — not your laptop.

This breaks every local setup out of the box. Whether you are trying to route Cursor through Ollama (http://localhost:11434), LiteLLM (http://localhost:4000), vLLM, or a custom proxy, Cursor's backend simply cannot reach your machine's localhost. The safe version of the same idea, cursor localhost base url not working, is exactly the symptom this post explains.

Why it looks like a broken proxy

When http://localhost:8082/v1 is configured in Cursor Settings:

The Cursor UI sends your prompt and context to api2.cursor.sh.
The Cursor backend tries to POST to http://localhost:8082/v1/chat/completions from its cloud servers.
The connection is refused or times out on the remote server.
Cursor UI shows "Reconnecting..." or a generic request error (500, 404, or a timeout).
Your local proxy logs stay 100% empty because no TCP connection ever touched your machine.

This makes debugging infuriating. The empty logs suggest your proxy isn't listening, when in reality the request died thousands of miles away before reaching your network.

Prove it to yourself in 2 minutes

You can confirm this exact behavior right now without changing your proxy code.

First, check that your local server works:

curl http://localhost:8082/health
# → 200 OK

Second, start an ad-hoc Cloudflare tunnel to expose that port publicly:

cloudflared tunnel \
  --config /dev/null \
  --url http://localhost:8082

Grab the generated https://<random>.trycloudflare.com URL from terminal output and test it from outside your local network (for example, from your phone over LTE):

curl https://<random>.trycloudflare.com/health
# → 200 OK

Paste that https://... address into Cursor Settings → Models → Override OpenAI Base URL. Send a prompt in Cursor chat. Your local proxy logs will instantly light up with incoming requests.

Switch the setting back to http://localhost:8082/v1, and it immediately hangs again. Same machine, same code, different origin.

Why a public tunnel is required by design

To let Cursor's cloud backend talk to a local process on your laptop, you need a public endpoint that routes back to your machine.

A Cloudflare tunnel creates an outbound-only WebSocket connection from your machine to Cloudflare's edge network:

Cursor backend
   ↓
https://<tunnel>.trycloudflare.com
   ↓
Cloudflare Edge
   ↓
Local machine (port 8082)
   ↑
outbound-only connection

Because your machine initiates the connection outward, you don't need port forwarding, static IPs, or open inbound firewall ports.

Tunnel configuration pitfalls that look like localhost bugs

Once people switch to a tunnel URL, they sometimes hit a new set of errors that look identical to the localhost issue:

Cloudflare returns 404 instead of reaching your proxy: If you have cloudflared installed locally, it may silently read ~/.cloudflared/config.yml. If that config contains ingress rules with a catch-all http_status:404 from a previous named tunnel, your quick tunnel will return Cloudflare's 404 page. Prevent this by passing --config /dev/null (see the command below).
HTTP 429 Too Many Requests: Anonymous trycloudflare.com quick tunnels share rate limits per IP. For permanent setups, use a named tunnel tied to a free Cloudflare account.
Port mismatch: Your proxy is listening on 8082, but cloudflared was started pointing at 8080.
404 from Cloudflare vs 404 from proxy: If curl https://<tunnel>/health returns 404 with a server: cloudflare header, the tunnel isn't reaching your port. If it returns a JSON error, the request reached your proxy.

To force a quick tunnel to ignore ~/.cloudflared/config.yml entirely:

cloudflared tunnel \
  --config /dev/null \
  --url http://localhost:8082 \
  --edge-ip-version 4

Step-by-step debugging checklist

If requests in Cursor chat hang or fail when using a custom Base URL:

Verify protocol: Is your Override OpenAI Base URL set to https://? Plain http://localhost will never work.
Test external connectivity: Run curl https://<your-tunnel-url>/health from a non-local network (e.g., mobile hot spot).
Check Cloudflare response headers: If curl returns a 404, check the headers. If server: cloudflare is present, fix the tunnel flags (--config /dev/null).
Inspect proxy authentication: Only after confirming the tunnel reaches your machine should you inspect OAuth tokens, API keys, or provider formats.

There is one more unrelated Cursor quirk: it silently unchecks the Override OpenAI Base URL setting every few hours, which silently sends requests through your API tokens instead. If your proxy suddenly stops receiving requests, check that checkbox first — I explain this bug in my post about using Claude and ChatGPT subscriptions in Cursor.

How Ungate automates this in Cursor

Setting up cloudflared manually every time you launch Cursor gets tedious. That's why I built Ungate — an open-source Cursor extension that connects Claude and ChatGPT subscriptions directly to native Cursor chat.

Ungate handles the entire proxy lifecycle automatically:

Starts a local proxy on an isolated port.
Spawns a platform-specific cloudflared binary with --config /dev/null to bypass local config conflicts.
Generates a local proxy API key so public tunnel URLs cannot be abused by unauthorized third parties.
Displays live proxy logs, request analytics, and tunnel status right inside Cursor's UI.
Auto-re-enables the Base URL setting when Cursor silently disables it.

You can install Ungate by searching for @id:orchidfiles.ungate in Cursor Extensions, or read the full setup guide here: How to use Claude and ChatGPT subscriptions in Cursor.

GitHub repository: https://github.com/orchidfiles/ungate

My Blog: orchidfiles.com
Telegram Channel: @orchidfiles

I built LoreData: a mock data generator with characters from Breaking Bad, Game of Thrones, Harry Potter, and other universes.

Orchid Files — Mon, 13 Apr 2026 16:47:01 +0000

In product demos, you often see names like John Doe, Jane Smith, Test User, and random emails like test@example.com. That works fine for smoke tests. It falls short in demos, seeds, mockups, and showcase pages.

The problem is not that the data is fake. The problem is that it is incoherent: the name and address are random, the bio feels disconnected, and the persona's interests and profession feel generated. In a demo, that is obvious right away.

I wanted a generator that builds not just a random set of fields, but a coherent persona from a single fictional universe.

Demo: https://loredata.orchidfiles.com

What LoreData does

LoreData generates personas from pop culture universes: The Simpsons, Star Wars, The Sopranos, and more. It currently supports 25 universes. Every field in a persona comes from the same universe.

import { person, group } from 'loredata';

const p = person({ universe: 'breaking-bad' });
// {
//   firstName: 'Walter',
//   lastName: 'White',
//   username: 'heisenberg',
//   email: 'blue_sky_cook@lospollos.com',
//   quote: "I am the one who knocks.",
//   profession: 'Chemistry teacher',
//   interests: ['chemistry', 'cooking', 'family'],
//   address: { street: '308 Negra Arroyo Lane', city: 'Albuquerque', state: 'NM' },
//   symbol: '☢️',
//   universe: 'breaking-bad'
// }

You can generate a group too:

const team = group({ universe: 'game-of-thrones', size: 3 });
// [
//   { firstName: 'Jon', lastName: 'Snow', username: 'lord_commander', ... },
//   { firstName: 'Daenerys', lastName: 'Targaryen', username: 'mother_of_dragons', ... },
//   { firstName: 'Tyrion', lastName: 'Lannister', username: 'halfman', ... },
// ]

This is not a replacement for Faker.js

Faker.js generates realistic random data. The fields may be valid, but within a single persona they are not really connected: there is no shared context and no character identity. LoreData solves a different problem: personas for interfaces, where recognizability and internal consistency matter more than field validity alone.

Install and CLI

npm install loredata        # library
npm install -g loredata     # CLI

The CLI supports filtering by interests, name, and output format:

loredata person --universe sherlock
loredata person --interests chemistry,cooking
loredata person --interests chemistry,cooking --interests-mode and
loredata person --name walter --format json
loredata group --universe friends --size 5
loredata universes

Deterministic output

If you need reproducible results, for example for test fixtures, just pass a seed:

const p = person({ universe: 'matrix', seed: 42 });
const team = group({ universe: 'matrix', size: 3, seed: 42 });

Given the same seed, you always get the same persona or the same group of personas.

Browser entry point

The library also supports browser environments through a separate entry point with no dependency on fs or path:

import { loadUniverse, personFromData } from 'loredata/browser';

const universe = await loadUniverse('breaking-bad');
const p = personFromData(universe);

It works with Vite, webpack, and any browser bundler.

How the project is structured

It is a TypeScript monorepo built with pnpm. It includes an npm package with the library, a CLI, and a web app for the demo.

The data lives in JSON datasets: each universe has separate files for metadata, characters, and addresses. To add a new universe, you only need to create data/{id}/meta.json, data/{id}/characters.json, and data/{id}/addresses.json. There is no manual registry. The loader picks up the new folder automatically.

Here, the data matters as much as the code. Product quality depends on canon accuracy: the right professions, real locations from the source material, and quotes that fit the character. AI agents handle about 90% of the dataset drafting work.

Who this is for

developers filling a local database or Storybook stories with recognizable personas
designers building mockups who do not want to use John Doe again
QA engineers creating more expressive test accounts with different profiles
tutorial and conference talk authors who want screenshots that feel less generic

Disclaimer

LoreData is an unofficial fan tool and is not affiliated with the rights holders of these universes, studios, or streaming platforms.

How to Connect MiniMax-M3 to Cursor

Orchid Files — Fri, 03 Apr 2026 10:30:38 +0000

The Missing Thinking and Reasoning Separation in Cursor

The documentation on the MiniMax website states that the model uses the OpenAI format and is compatible with most IDEs. But it turned out that if you connect it to Cursor, it doesn't separate the contents of <think>...</think> from the actual response; everything goes into a single stream. You see the model's thoughts and the response mixed together, and at some point it becomes unclear where its thoughts end and the response to the user begins. Working in this mode is extremely inconvenient.

How Ungate Fixes It

I've added MiniMax support to the Ungate extension for Cursor that I'm developing. It processes content from <think>...</think> blocks, and now Cursor correctly separates the model's reasoning from the response to the user. Working with MiniMax in Cursor is now the same as with other OpenAI-compatible models.

Without Ungate, the model's thoughts and the answer arrive in one stream — a single text block where the reasoning and the response run together:

<think>... I need to check the project structure first. Let me list the files
and then propose a plan...</think> But the actual answer continues right here,
so it is unclear where the thinking ends and the response begins.

With Ungate, Cursor correctly separates the model's reasoning from the response, and only the answer reaches the chat:

Here is the final plan for the task.

Login and tunnel setup for the extension are the same for MiniMax as for other models — see How to use Claude and ChatGPT subscriptions in Cursor.

Connecting MiniMax in Cursor

To access the model, you need to add the custom model name to Cursor:

MiniMax-M3

I've added a Base URL selector for MiniMax to the Ungate settings:

China
Global
Custom

Quality and Speed: Benchmarks vs Practice

MiniMax-M3 is a new Chinese frontier model from MiniMax. According to some benchmarks, it has almost caught up with Claude Opus 5. However, based on my tests over the past few days, I've concluded that it doesn't even measure up to Claude Sonnet 5. If you use it for simple tasks, everything is fine.

But if you have a monorepo project structure with packages and apps, you have to run a lot of iterations to complete tasks. Even if the rules and skills specify the project structure — where types, helpers, and ESLint configurations are located — it still doesn't follow that structure. And it's very slow compared to Sonnet, and it's about 20 times slower than GPT-5.6. I asked the agent with MiniMax to copy the structure from another monorepo repository, and it took me 4 hours of back-and-forth with the agent to clarify the details so that it would finally complete the task. With Claude Sonnet 5, this takes me about 15–30 minutes.

Benchmarks and real-world performance differ greatly. If a model is estimated to be close to Sonnet or even Opus in benchmarks, in practice there may be a significant gap between them.

Pricing and Value

You need to consider not only quality and speed, but also price. MiniMax is 10 times cheaper than Claude Sonnet 5. A $10 subscription gives you:

1,500 queries every 5 hours
15,000 queries per week

I also noticed that MiniMax's planning capabilities are quite good — comparable to Sonnet or GPT. Therefore, for simple tasks or situations where speed isn't a priority, MiniMax can be a reasonable choice.

My Blog: orchidfiles.com
Telegram Channel: @orchidfiles

How to use Claude and ChatGPT subscriptions in Cursor instead of paying for API tokens

Orchid Files — Thu, 02 Apr 2026 07:53:12 +0000

TL;DR: Claude and ChatGPT subscriptions can be used in Cursor through OAuth login and a local proxy exposed via a Cloudflare tunnel — no API tokens needed. The open-source extension automates the whole flow: login, proxy, and tunnel are handled in one minute. Install and configure it: https://github.com/orchidfiles/ungate

In Cursor, you can connect any LLM via API that is compatible with the OpenAI request format. However, if you have a Claude or ChatGPT subscription, you won't be able to use them directly in Cursor. Their request formats differ from the OpenAI API format, so you'll need a workaround — proxying the requests.

There are already solutions on GitHub that convert the OpenAI format to the provider's required format and back. But to add this to Cursor, simply running the process on localhost and adding it to Cursor is not enough, because Cursor first sends requests to its own backend, and from there to an OpenAI-compatible API. If you add localhost there, their backend simply won't be able to reach it. That's why you need to set up a tunnel that forwards traffic to your localhost. Cloudflare is very well suited for this. With the cloudflared tunnel command, you can start a tunnel and add the tunnel address to Cursor.

Ungate

Ungate is an open-source Cursor extension that connects your Claude or ChatGPT subscription to Cursor's native chat. You log in via OAuth in your browser, the extension runs a local proxy that converts the request formats, and it sets up a Cloudflare tunnel automatically. The whole setup takes one minute.

Most existing solutions retrieve the Claude subscription token in two ways. The first method works only if you already have the Claude CLI installed and are logged in to it. It retrieves the token that the Claude CLI has stored on your system. The second method is not tied to the Claude CLI and allows you to log in to Claude in your browser using OAuth and add the token.

These solutions do not support everything required for development. In some of them, only chat is proxied properly, while tool use, such as modifying files or using planning mode, is not supported. Others support only some tools, but not all of them. In some cases, only Claude is supported, and ChatGPT does not work.

I took the best features from these solutions, added support for all tools, and created a Cursor extension:

OAuth login for Claude and ChatGPT, no CLI required
Full tool support: chat, file edits, planning mode
Automatic Cloudflare tunnel — no manual cloudflared setup
Dashboard with request statistics and logs
Auto-fix for Cursor silently disabling the custom Base URL setting

The entire setup takes just one minute, and you can use your subscriptions in Cursor instead of paying for API tokens.

GitHub: https://github.com/orchidfiles/ungate

Claude vs ChatGPT subscriptions in Cursor

Both subscriptions work through the same proxy flow, so the choice mostly comes down to models. Claude keeps its token refreshed automatically. ChatGPT needs re-authorization via OAuth every few weeks — until you do it, requests will fail with an error.

Beyond that, the difference is the models themselves. Any Claude model is available via a custom model ID, and the same applies to GPT models.

The economics are straightforward:

A $20 ChatGPT subscription gives access to ~$1,000 worth of tokens
A $100 Claude subscription gives access to ~$2,000 worth of tokens
Total cost: $20 for a Cursor subscription plus your existing provider subscription — instead of paying for API tokens

You can also connect both subscriptions at the same time and switch between them in the same chat.

Official extensions vs Ungate

Anthropic ships its own Claude Code extension for Cursor (anthropic.claude-code). OpenAI ships a mirror one — the Codex extension (openai.chatgpt). Both are official, and both work differently from Ungate:

Aspect	Official extensions (Claude Code, Codex)	Ungate
Where requests run	A separate agent panel with its own UI, context, and history	The native Cursor chat: Chat, Agent, and Composer
Providers	One provider per extension — Claude Code only works with Claude, Codex only with GPT	Claude and ChatGPT subscriptions in one place
Model picker	Only the models of that one provider	Any Claude or GPT model, switch providers in one place
Setup	The official extension/CLI plus the matching subscription	OAuth login in browser, one minute total
Cursor UX	Separate workflow, separate diff review	Native Cursor diffs, context, and tools

The official extensions put a second agent with its own workflow next to Cursor — Claude Code locked to Claude, Codex locked to GPT. Ungate does the opposite: it routes requests through your subscription inside the native Cursor interface, so you keep the model picker, diff review, and context you already know — and you can use the same setup for both Claude and ChatGPT.

In practice this means a workflow that no official extension can offer: ask GPT through your subscription to write a solution, then ask Claude through your subscription to review the result in the same chat. When you're ready to implement, toggle proxying off with one button right below the chat, switch to Cursor's Composer, and later turn proxying back on to have GPT or Claude check the changes.

Installation

You can install the extension from the Extensions panel in Cursor by searching for @id:orchidfiles.ungate.

Installation from the terminal: cursor --install-extension orchidfiles.ungate

You can also compile the extension from source:

git clone https://github.com/orchidfiles/ungate.git
cd ungate
pnpm install
pnpm run package:build
cursor --install-extension "apps/extension/out/ungate.vsix"

After installing the extension in Cursor, a button labeled Ungate: API running | Tunnel stopped appears in the status bar. It means the proxy service is running and the tunnel is paused. Clicking it opens the Dashboard with proxied request statistics and settings. In Settings, you can change the port, restart the tunnel, log in to Claude and ChatGPT via OAuth, and view the tunnel and proxy logs.

Initial setup:

Start a tunnel in the dashboard and get the URL from Cloudflare.
Paste this URL into Cursor Settings -> Models -> API Keys -> Override OpenAI Base URL.
Copy the API Key from the dashboard and paste it into Cursor Settings -> Models -> API Keys -> OpenAI API Key. This is not your subscription key, but the API key for the proxying service, so that other people cannot make requests to your localhost. It's generated when the extension is installed.
Copy the ID of the desired model and add a custom model in Cursor using that exact name.

Once you've done this, you can select this model in Cursor chat, and all requests will be routed through your subscription.

The extension has a quick actions menu. When you hover over the extension in the status bar, a tooltip will appear. In it, you can restart the tunnel, copy the tunnel address, and toggle request proxying.

Issues, Limits, and Notes

Cursor automatically disables the custom OpenAI Base URL setting every few hours, causing all requests to go through API tokens again. This "bug" has existed for a very long time, and they haven't fixed it. I think it's not economically viable for them to fix this bug. The extension automatically checks whether this setting is enabled. When Cursor unchecks this, the extension re-enables it.
Standard model names in Cursor only work for certain providers. For example, if you send a request using the built-in GPT-5.4 model, the request will go through the proxy using your subscription. But if you use Sonnet 4.7, the request will go through the API to Claude using tokens. In the extension, you can create custom model names and add them to Cursor so that requests are guaranteed to go through the proxy.
To avoid releasing a new extension for every version of Node and OS, the extension downloads the better-sqlite3 and cloudflared builds from their repositories during the initial installation.
If you disconnect your laptop from the internet and then reconnect, you need to restart the tunnel. If you see "Reconnecting..." when making a request in the chat, you need to restart the tunnel.
If you receive a 401 error when making requests, it means you have an incorrect API key. You need to go to the extension's Dashboard, copy the api-key, and paste it into Cursor Settings -> Models -> API Keys -> OpenAI API Key.
If you receive a 404 error, it means the tunnel is not running or the tunnel address is incorrect.
Automatic token refresh only works for Claude. With ChatGPT, you need to re-authorize your account via OAuth every few weeks.
Your usage through the proxy counts against the same limits as your regular subscription usage. The dashboard shows proxied request statistics, so you can track consumption. If you hit a limit, the provider throttles or blocks requests until the usage window resets.
Using a subscription outside official clients sits in a gray zone. Anthropic updated its terms in February 2026 to prohibit extracting OAuth tokens outside the official Claude Code client; OpenAI has similar restrictions. I have been using this setup for over six months without account issues, but that is not a guarantee. Use it at your own risk — the code is open source, so you can audit exactly what it does.

If something does not work in the extension, or if you have any questions, please create an issue on GitHub or write here in the comments. Contributions are welcome: open a pull request if you want to improve the code — I review all PRs within 24 hours and either merge them or leave comments.

Blog • Telegram channel

PM2 has no web UI. Every open source alternative is dead. So I built one.

Orchid Files — Wed, 18 Mar 2026 18:11:06 +0000

Why I started this project

PM2 is the most popular process manager for Node.js, with 2 million downloads per week, but it's provided as a CLI tool. If you want to view processes in a browser, manage them, and receive notifications via Slack or email, you need to use PM2 Plus. This is a paid, subscription-based cloud service.

All open-source alternatives are built using JS+HTML. They lack modules, type safety, tests, and an architecture designed for extensibility. They are difficult to maintain and develop. You can't simply fork them and add new features without rewriting most of the code. And since they lack tests, you can break anything with your changes.

Almost all open-source solutions have been abandoned. The most popular ones, based on star count, haven't been updated in 2 to 10 years. Some have issues that have been open for years, and pull requests aren't accepted. The authors have abandoned these projects. Yet new repositories pop up every few months, but they're still just plain JS with a single routes file and a few pages on the frontend. Without any well-thought-out architecture.

I've been using pm2 for about 10 years now, and I've wanted to create a pm2 dashboard for a long time. AI agents make this kind of project much faster to build. That doesn't mean this is just some vibe-coding project where I simply asked the AI to create a dashboard and dumped the code into Git. I make 100% of the architectural decisions, review 100% of the code, and I write each new task for it in a new chat. The AI agent doesn't make decisions; it only handles the routine tasks: writing code, tests, and markup.

Fun fact. When I started brainstorming a name for the npm package, I went through dozens of options and settled on pm2-dashboard. It had been taken by an inactive package for 11 years and became available 11 days before I started choosing a project name. I managed to grab it and publish a placeholder. It seems like a huge coincidence that the best possible name for the project became available at just the right moment.

How the project is structured

I decided to build a project that would be very easy to extend and maintain — with full TypeScript coverage, test coverage, linters, and a modular architecture. For the structure, I chose a monorepo approach: apps, packages, scripts, and docs. As usual, packages/shared contains shared modules, constants, types, and helpers.

For the frontend, I chose between Vue, React, and Svelte. I'm familiar with all of them, but I chose Svelte because I prefer its style over React's, and I haven't worked with Vue in a long time. Fewer developers are familiar with it, which might complicate maintenance, but if you work with AI agents and know Tailwind, there won't be any issues.

On the backend, I immediately chose NestJS for its dependency injection and modular architecture; it's better for scalability than Express or Fastify. I also considered AdonisJS, but it's less popular. It might take longer to set up initially, but I simply asked an AI agent to port the existing NestJS code from my other projects. But it pays off in both maintenance and extensibility.

For the database, I chose between PostgreSQL and SQLite. I chose SQLite because so the package can be installed with a single command from npm, and there's no need to spin up a Docker container for the database — the entire database is in a single file. For the ORM, I chose between TypeORM and Drizzle. I chose Drizzle because I hadn't worked with it yet and wanted to gain some experience, and it seems like most new projects are choosing it now.

Between JWT and cookie-based sessions, I chose the latter because JWT offers no advantages for a self-hosted tool with a few users, but it complicates logout and token deletion. Surprisingly, I couldn't find a library that works with express-session and better-sqlite3 and writes sessions to the same database file. connect-sqlite3 writes sessions to a separate file, and better-sqlite3-session-store has a license incompatible with MIT. I built my own session solution in 30 lines of code.

On first launch, a setup wizard appears, prompting you to create a user; after that, access to the interface is available only via username and password. No .env or other configuration files.

It took 5 days from the project idea to a working version and writing this post. Without AI agents, it would have taken much longer. And without AI agents, I probably wouldn't have even started this project.

What's already working

List of processes with CPU, RAM, and status
Start, stop, and restart for each process, as well as bulk operations
Uptime and restart counters
Authentication
Setup wizard on first launch
A single npm package with API and web interface

Next priorities

Real-time updates via WebSocket
Log viewer
Metrics history with graphs
Alerts

How to try it

npx pm2-dashboard

It will open at http://localhost:3000. On first run, the CLI prints a setup link.

GitHub: https://github.com/orchidfiles/pm2-dashboard

Beyond technical posts, I write essays and short observations on orchidfiles.com and Telegram.

Stigma is a tax on every operational decision

Orchid Files — Sat, 14 Mar 2026 10:43:00 +0000

If you are planning to create an online casino or a copy of OnlyFans, you most likely want to get in quickly, make money fast, and get out. You are unlikely to stick with it for 10 years. Just as many criminals hope to pull off one last heist, earn a living, and never do it again. The idea of one last job sounds heroically romantic.

Working on an 18+ project feels like being a rock star. You work with 18+ content, see the audience, see the performers, and get access to what feels like something secret. Some see it as excitement, risk, drama, and a feeling of being alive. And then it turns out that stigma is built into almost every operational decision: hiring, advertising, payments, investments, social circle, and reputation. Stigma is the price you pay for permission to exist.

You may have a cool product in the field of sports betting, casinos, or lotteries. But almost all social networks and search engines won’t let you advertise without a license from the required jurisdiction. Finding investment for such projects is far harder than for conventional niches. Do you want to build an AI-powered 18+ video generator? When posting job openings, you will always have to beat around the bush, without using direct language. And only then, when the candidate has already agreed to an interview or even after it, do you tell them what kind of content they will be working with every day.

Employees join such projects for various reasons. Some realize that the pay is better than in legitimate projects. Others come because they couldn’t find a job where they wanted to, or because they are simply interested in working on something forbidden. And then a good company saving the world will come along and offer them a job, and they’ll leave. Building a stable team from people with this kind of motivation is hard.

Payment providers, including Stripe, do not work with 18+ and gambling. You will have to look for others. A regular provider charges a regular commission but will not work with you, while another will want a commission 10 times higher and will agree, but may stop working with you at any time. These are often unreliable providers who are willing to work with risky categories. Or you will have to give up payment providers altogether, accept only cryptocurrency, and set up the processing yourself, because even many crypto processors prohibit these categories. Your creatives won’t pass moderation on ad networks. Accounts will be blocked for advertising prohibited projects. You need constant account warming, proxies, anti-detect browsers, moderation bypasses, and cycling through accounts. All of this takes a lot of time and money. Venture investors refuse to fund such projects, so they are often financed with personal money or money from friends. There are few who want to hedge their portfolio or just dabble in this space because it gets their blood pumping too.

Formal rules and legal protection mechanisms, which are common in legitimate projects, do not work well here. Many companies in these areas are not registered at all. They operate through nominees, without an office, without official salaries, and without paying taxes. When the business itself is illegal, the courts and police no longer seem like a natural means of protection. So competitors resort to spam, DDoS attacks, data leaks, hacking, fake reviews, and reputation damage. If your company also operates unofficially and your competitors want to eliminate you, they will not be able to do so officially and will look for other ways. And they may find them.

This kind of business can’t make you proud if you’re not in an environment that appreciates it. If all your friends go to church on Sundays or your wife is an elementary school teacher, they’re not likely to approve of a webcam studio business. Your other half will feel uncomfortable talking about what you do. She won’t talk about it with her friends or at work parties. This will constantly weigh on you, even if you don’t notice it at first. Your religion or the religion of those around you may also disapprove. Life is not what happens to you, but what you are able to talk about. But if the product becomes successful, how will you talk about it to your friends? If you built the best casino site, it feels like you are participating in the decay of society and are proud of it.

Or you have a traffic arbitrage project: you buy traffic on Google and use cloaking to direct it to casino sites via referral links. You find an excuse: if it weren’t for you, someone else would be doing it. You’re not stealing money from a card, you’re just connecting a Google search to a casino site, and then the person loses tens of thousands of dollars themselves. You don’t force the person to make a deposit, you don’t take money from their card, you don’t gamble their money away. It’s like you’re not to blame. People gamble at casinos, but society shifts the blame onto those who build a business on it. When a person tries to find excuses for their actions, it means they feel uncomfortable but keep going. In niches without stigma, such rationalizations are unnecessary.

Success in a stigmatized niche rarely translates into reputation beyond it. You’ve built a product with a million users, but you can’t always add this project to LinkedIn without damaging your reputation. You spent 5 years, achieved significant revenue, somehow assembled a team and pay them well above market rates so that people don’t leave for a more legitimate project, made contacts in related projects, analyzed your competitors, and know this market well. And the better you made the product, the more you are tied to a niche that is difficult to leave.

Blog: orchidfiles.com
Telegram channel: @orchidfiles
Email: orchid@orchidfiles.com
Telegram DM: @askorchid

AI will build your roadmap in 10 seconds

Orchid Files — Tue, 24 Feb 2026 00:00:00 +0000

You can ask AI to think and plan, for example, to draw up a marketing plan for a project. And it will “think” and compose a beautiful text with arguments, breaking the plan down into stages, phases, periods, and categories. But this plan will have nothing to do with reality.

Build a 7-year growth roadmap for my project

Phase 1 (0-6 months): launch, first 100 users from personal network and early adopters
Phase 2 (6-12 months): organic growth, 500-1,000 users, early feedback and product iterations
Phase 3 (1-2 years): product-market fit, 3-5K users, introduce paid acquisition channels
Phase 4 (2-4 years): scaling, 10-30K users, achieve sustainable revenue
Phase 5 (4-7 years): maturity, 50-100K users, expand into adjacent markets and segments

How many downloads will my app get after launch?

Pessimistic: 100-500 in the first month
Realistic: 1,000-3,000 in the first month
Optimistic: 10,000+ in the first month

How do I attract the first users to my product?

Create an account on Twitter/X and start posting build-in-public content

Write an article on Hacker News

Launch on Product Hunt

Start a free newsletter with valuable content

Find 10 relevant communities on Reddit and become an active participant

These answers are equally useless. Even if you provide him with the context of the project and the decisions made earlier, he still won’t be able to think. He will only write a plausible plan. In reality, you’ll find that posts on HN rarely make it to the front page, there is no one to send the newsletter to, X hardly ever generates clicks on external links, and Reddit bans self-promotion.

He can convince you that your startup is definitely a blue ocean and your key feature is your product-market fit. But the future is stochastic. AI models cannot predict it. His pessimistic predictions are never zero. Most likely because the training data in such predictions most often does not have zero. Although if you ask him, “But there could be zero users in a year, right?”, he will agree with that. His predictions are just another way of saying “I don’t know”.

Planning with AI is almost no different from planning by an incompetent person. A person without AI can draw up the same plan. But in most cases, whether it’s planned by a person or AI, the plan will not survive the collision with reality. People have always passed off plausible text about the future as forecasts. AI has simply accelerated this. Previously, it was expensive and time-consuming, so it seemed valuable. Now AI generates the same plausible plan in 10 seconds, and it becomes clear that the emperor has no clothes.

My blog has all of my essays and notes, and I also write on Telegram.

Email: orchid@orchidfiles.com · Telegram: @askorchid

Startups remember backups after the crash

Orchid Files — Wed, 11 Feb 2026 00:47:22 +0000

In startups, something often seems more urgent than backups: a new release, user growth, the next round of funding. When resources are scarce, the team focuses on building the product, not the infrastructure. And every day, shipping wins. Backups keep getting postponed. Not just because there’s no time, but because thinking about them means admitting how fragile everything is, and how much rests on the people behind it. In the early stages, it’s often just a single backup. No automation, no established processes. Beneath it lies a quiet belief that disasters happen to others — until the first failure shatters that illusion within seconds, and you discover there are no copies, access is lost, and nothing can be recovered.

You don’t learn how resilient your system is until it breaks. Even the most reliable systems are not immune to rare, unpredictable events. Sometimes a single accident is enough to put everything at risk. A fire, a flood, or a lightning strike can destroy both originals and backups if they’re stored in the same place.

The loss of code, documents, and databases erases not only a project’s memory but the time that went into it. It feels like everything is gone — until you manage to recover at least part of the data. What comes after is relief, and a realization of how close everything came to being lost. Sometimes recovery never comes, leaving only emptiness.

After something like this, you never think about your systems the same way. It’s the point where a founder starts caring not just about growth, but about what’s already running. Making a backup means accepting that the system is vulnerable. But at least you’ve done something about it. It brings back a sense of control that’s easy to lose when you’re focused on shipping.

Catastrophes don’t start in code; they start in the decisions around it — running the wrong command, deleting the wrong file, acting in moments of haste or fatigue. One mistake can erase years of work. Sometimes it’s human error; sometimes it’s a system we trusted too much. Technology creates the illusion of safety: when everything is stored in the cloud or syncs automatically, it instills confidence that nothing will go wrong. As long as it works, we think we’re in control. But any protection weakens the moment it stops being tested. Panic doesn’t come from the loss itself, but from the realization that there was no plan. Security isn’t about feeling in control. It’s about having a plan for when you’re not.

Data loss isn’t just a technical failure. It’s a breach of trust. Even if the data can be recovered, restoring reputation is much harder. A single failure can erase years of credibility in the eyes of investors or users.

Security is a habit of taking care of what you’ve built. It doesn’t demand perfection, only attention. Imperfect protection is better than none. And a tested backup is better than the illusion of stability. Sometimes all it takes is one evening — make a backup, test restoring it, and finally sleep soundly.

Technology evolves. Complacency endures.
Building something means taking responsibility for its survival.
It’s respect for time that can never be regained.

All of my essays are available on my blog.
I post notes every day on my Telegram channel.

You can reach me by email or on Telegram. I reply to all messages.

The limits of interview questions

Orchid Files — Sun, 08 Feb 2026 11:49:17 +0000

When I worked as a developer and team lead, I went through a lot of interviews. Over time, I built up a list of odd and unhelpful questions. There were many, but here are the ones that stood out the most. I’m not trying to guess what the interviewers were thinking. I’m just showing how these questions sound in conversation and the impression they leave.

The Quirky Ones

What’s your favorite color and why?
What animal do you associate yourself with?
How would you describe your perfect day?

These questions sound unusual, but they don’t tell you anything about how a person works. The answers are wide open to interpretation, so the focus shifts from real experience to guessing the right image. A candidate either recites something they’ve prepared or improvises a response, and neither option says much about how they approach problems. It’s hard to draw any conclusions about work behavior or decision-making from answers like these. More often than not, they add noise rather than help with evaluation.

Passive-Aggressive Traps

Aren’t you worried you won’t keep up with our pace?
Don’t you think you might be overqualified for this role?
How do you explain the long gaps in your career?
How much were you making before?

These questions often feel like an attempt to uncover a hidden problem. They focus less on professional experience and more on external circumstances, which rarely help you understand how someone will work in a team. This stands out even more in startups. A person’s past salary doesn’t reflect their current motivation or expectations. A long career break might have nothing to do with competence. And a concern about being overqualified means nothing without context about the role. It’s easy to misread signals like these and turn down someone who might actually be a great fit.

There’s one question that sits on the edge of what’s fair: “Why have you changed jobs so often?” It can be a reasonable one — if you understand that the answer often reflects the natural lifecycle of projects, not the candidate’s behavior. That’s exactly how it was in my case. I worked at startups, and most of them shut down in their first year.

Not Quite Therapy

What do you think your friends would say about you?
What about your personality makes you doubt yourself?
How do you handle situations when things don’t go as planned?

These questions seem like an attempt to assess maturity and self-awareness. In practice, they shift the conversation into personal reflection under observation. The candidate doesn’t have time to think it through or ask for context. They came to talk about work — and suddenly they’re expected to quickly explain their own reactions and motives. Without a prepared answer, they start guessing what kind of response is expected. That forces them to improvise. In the end, the interview ends up measuring not how well they’d do the job, but how well they handle being put on the spot.

The Culture Fit Game

Why do you believe you’re a good fit for this role?
How do you think your experience could benefit our team?
Why do you want to work with us specifically?
Which of our company values resonate with you?

These questions assume the candidate made a deliberate choice and took the time to learn about the company. In reality, many people apply to dozens of roles at once and only start learning the details after they get an interview. Their understanding of internal processes and values is limited, so their answers tend to reflect not a real connection with the company, but an attempt to sound motivated without much to go on. As a result, the answers come out generic and don’t say much about how the person actually works.

The Last Job Focus

What kind of tasks did you handle in your last role?
What challenges did you face on that project?
Why did you leave that company?
What was your role in the team at the time?

These questions are reasonable on their own, but interviews often end up focusing almost entirely on the candidate’s most recent project. That project might have been short, irrelevant to the role, based on a different level of responsibility, or simply untypical in terms of tasks. As a result, the conversation revolves around a fragment that says little about the candidate’s broader experience. The person may have led a larger team before, worked on a different scale, or operated in a different environment — but that gets lost if all attention goes to the last job.

I’ve often tried to zoom out and explain that what matters is the full arc of experience, not just the latest entry. But the conversation kept circling back to that one last project, as if it had to explain everything. This focus skews the outcome. If the last project is an outlier — the easiest one, the least successful, or simply the odd one out — then the answers reflect a random moment in someone’s career. It’s easier to talk about, but it says very little about the actual experience.

At the end of the interview, it comes down to a simple question: did you understand the person — and did they understand you?

For longer reads, visit my blog.
For daily notes, follow my Telegram channel.

If you want to reach out, contact me by email or on Telegram. I reply to all messages.

DEV Community: Orchid Files

Why localhost doesn't work as OpenAI Base URL in Cursor — and how to fix it

How Cursor actually routes OpenAI Base URL requests

Why it looks like a broken proxy

Prove it to yourself in 2 minutes

Why a public tunnel is required by design

Tunnel configuration pitfalls that look like localhost bugs

Step-by-step debugging checklist

How Ungate automates this in Cursor

I built LoreData: a mock data generator with characters from Breaking Bad, Game of Thrones, Harry Potter, and other universes.

What LoreData does

This is not a replacement for Faker.js

Install and CLI

Deterministic output

Browser entry point

How the project is structured

Who this is for

Disclaimer

Links

How to Connect MiniMax-M3 to Cursor

The Missing Thinking and Reasoning Separation in Cursor

How Ungate Fixes It

Connecting MiniMax in Cursor

Quality and Speed: Benchmarks vs Practice

Pricing and Value

How to use Claude and ChatGPT subscriptions in Cursor instead of paying for API tokens

Ungate

Claude vs ChatGPT subscriptions in Cursor

Official extensions vs Ungate

Installation

Issues, Limits, and Notes

PM2 has no web UI. Every open source alternative is dead. So I built one.

Why I started this project

How the project is structured

What's already working

Next priorities

How to try it

Stigma is a tax on every operational decision

AI will build your roadmap in 10 seconds

Startups remember backups after the crash

The limits of interview questions

The Quirky Ones

Passive-Aggressive Traps

Not Quite Therapy

The Culture Fit Game

The Last Job Focus