Every dev shop has a list of internal tools nobody has time to build. A client dashboard. A time tracker that actually works. A project status page the ops lead doesn't have to compile by hand. These aren't hard projects. They're just never urgent enough to justify pulling a senior developer off billable work.

Cursor changes that math. Its Agent Mode lets you describe what you want in plain English, and it writes the code — across multiple files, with your tech stack, using your existing database. You go from "I need a simple app" to a working internal tool in a few hours instead of a few sprints.

This post walks through the process: picking a tool to build, setting up Cursor for the job, and using Agent Mode to ship it.

Why Internal Tools Stall

The pattern is always the same. Someone — usually the ops lead or the founder — identifies a need. "We need a dashboard that shows active projects, burn rate, and upcoming deadlines." The team agrees. It goes on a backlog. It stays on the backlog for six months because every developer hour is allocated to client work.

Meanwhile, the ops lead spends 5-8 hours a week manually compiling that information from Jira, Harvest, and Slack. The cost of not building the tool is real. It just doesn't show up on an invoice.

Cursor doesn't make the tool build itself. But it cuts the development time enough that a junior developer — or even a technical founder with a free afternoon — can ship something functional. Agent Mode handles the boilerplate, the data fetching, and the layout. You handle the decisions.

What You Need Before You Start

Cursor Pro or Business. The free tier works for casual use, but Agent Mode with full codebase context requires a paid plan. Pro is $20/month. Business is $40/month and adds team features.

A tech stack decision. For internal tools, keep it simple. Next.js for the frontend, Supabase for the database, and Tailwind for styling is a solid default. If your team already uses something else — Rails, Django, Vue — Cursor works with that too. It indexes your codebase and adapts.

A clear scope. Agent Mode works best when you know what you want. "Build me a dashboard" is too vague. "Build me a page that shows all active projects from our Supabase database, with columns for project name, client, status, hours burned, and hours remaining" gives the agent something to work with.

Setting Up Cursor for the Job

Step 1: Create the project and index your codebase

Open Cursor and create a new project (or open an existing repo). Cursor automatically indexes the codebase so the AI understands your file structure, dependencies, and patterns.

If you're starting fresh, open Agent Mode (Cmd+I on Mac) and tell it what you want:

Set up a new Next.js project with Tailwind CSS and Supabase. Use the App Router. Create a basic layout with a sidebar navigation.

Agent Mode creates the files, installs dependencies, and configures the project. Review what it wrote, accept the changes, and you have a scaffold in minutes.

Step 2: Add a Rules file

A .cursorrules file tells the AI how your team writes code. Drop one in the project root with your standards:

Use TypeScript for all files.
Use functional components with hooks.
Use Tailwind CSS for styling — no CSS modules.
Use Supabase client library for all database queries.
Keep components under 150 lines. Extract subcomponents when they get longer.

Every Agent Mode interaction now follows these rules. No more cleaning up code style after the AI generates something.

Step 3: Connect MCP integrations

MCP (Model Context Protocol) lets Cursor talk directly to your tools. The two most useful for internal tool development:

Supabase MCP — Cursor can query your database schema, understand your tables, and write queries that match your actual data. Add it in Cursor Settings > Tools & MCP, or drop this in your .cursor/mcp.json:

{
  "mcpServers": {
    "supabase": {
      "url": "https://mcp.supabase.com/mcp"
    }
  }
}

GitHub MCP — If you're working from an existing repo, the GitHub MCP server lets Cursor read issues, PRs, and code context. Useful when the internal tool needs to pull data from your development workflow.

Once connected, Agent Mode can query your actual database tables and understand your schema when writing code. No more pasting schema definitions into the chat.

Building the Tool: Three Examples

Example 1: Client Dashboard

Tell Agent Mode:

Build a dashboard page at /dashboard that queries the Supabase "projects" table. Show a card grid with each project's name, client, status, and budget utilization as a percentage. Add a status filter dropdown at the top. Use Tailwind for all styling.

Agent Mode creates the page component, the Supabase query, the card layout, and the filter logic. It writes multiple files at once — the page, any shared components, and type definitions. Review each file, make adjustments, and accept.

Follow up with: "Add a click handler on each card that opens a detail panel showing project timeline, assigned team members, and recent activity."

Each prompt builds on the last. You're directing, not coding.

Example 2: Time Tracker

Create a time tracking page at /time. It should show a form with fields for project (dropdown from the projects table), task description, and hours. When submitted, save to a "time_entries" table in Supabase. Below the form, show today's entries in a table with a running total of hours.

Agent Mode handles the form, the database insert, the query for today's entries, and the sum calculation. If the time_entries table doesn't exist yet, it can even generate the SQL migration for you.

Add to it: "Add a date picker so I can log time for previous days. Add a weekly summary view that groups entries by project and shows totals."

Example 3: Project Status Page

Build a status page at /status that pulls data from the "projects" and "milestones" tables. Show each project with its milestones as a timeline. Color milestones green if completed, yellow if in progress, red if overdue. Make it printable for client meetings.

This is the kind of page the ops lead has been building manually in a spreadsheet every Friday. Now it updates itself from the database.

Tips for Getting Good Results

Be specific about data. Agent Mode writes better code when it knows your actual table names and column names. With the Supabase MCP connected, it reads your schema directly. Without it, paste your schema into the conversation.

Build incrementally. Don't try to describe the entire tool in one prompt. Start with the core feature, review the output, then layer on functionality. Each follow-up prompt can reference what's already been built.

Use the Rules file for consistency. If Agent Mode keeps generating code in a style you don't like, add a rule. "Always use async/await, never .then() chains" or "Use date-fns for date formatting, never raw Date methods." The rules apply to every generation.

Review everything. Agent Mode is fast, not infallible. Read the generated code. Check the database queries. Test edge cases. The tool writes your first draft. You own the final product.

What This Saves You

A client dashboard that would take a developer 2-3 days of focused work can ship in 3-4 hours with Cursor. A time tracker might take an afternoon. A status page, a couple of hours.

More importantly, the person building it doesn't have to be your most senior engineer. A mid-level developer with clear requirements and Cursor's Agent Mode can ship internal tools that used to sit on the backlog for quarters. That senior engineer stays on the client project where they belong.

The internal tools get built. The billable hours stay intact. The ops lead stops compiling spreadsheets.

---

Want to see where AI-assisted development fits in your team's workflow?

Take the free AI Readiness Assessment -- it takes a few minutes and gives you a concrete picture of where tools like Cursor can make the biggest difference.

Or if you'd rather talk through your specific setup: Schedule a free call.