Copilot Solo Cheap Tier

Every other week someone tells me I am leaving performance on the table by not running some agent that spawns five subagents and burns through tokens like a space heater. Maybe. But I am one guy with a SaaS that makes enough to pay rent, and the math I actually care about is cost per edit. GitHub Copilot is a flat low monthly price, the completions come back in about a second, and I never get a surprise bill. That is the whole pitch. Let me show you the setup, because it is almost embarrassingly small.

The honest reason I picked it

I tried the agentic stuff. I really did. The problem was never that it could not do the work, it was that I would look at a usage dashboard at the end of the week and feel a little sick. With Copilot the number does not move. It is predictable, and when you are bootstrapping, predictable is worth a lot more than a few extra points on a benchmark. My build leans on inline completions for the typing I do all day and chat for the moments I am genuinely stuck. That is it. The model under the hood right now is GPT-5.3 Codex, which is fast enough that I forget it is there.

Custom instructions do most of the heavy lifting

Copilot reads a file at .github/copilot-instructions.md and applies it to every completion and chat in the repo. This is the single highest-leverage thing in my whole setup. I keep it short on purpose, because a wall of text just makes the suggestions mushier. Here is the actual file from my main project.

# Project: ledgerlite (solo SaaS)

Stack: TypeScript, Node 20, Fastify, Postgres, Vitest.

## How I work
- Prefer inline completions for speed. Suggest the next few lines,
  not a whole essay of a function.
- When I open chat it means I am stuck. Be direct, show the diff,
  skip the preamble.
- Keep everything in one repo. Do not invent new packages or
  microservices. This is a monolith and it stays a monolith.

## Style
- No default exports. Named exports only.
- Throw typed errors from src/errors.ts, never bare strings.
- Tests live next to the file as *.test.ts and use Vitest.
- No comments that just restate the code.

Those three bullets under How I work are literally the rules from my build, written so the model actually reads them. The Keep everything in one repo line matters more than it looks. Left alone, the assistant loves to suggest splitting things into a shared package, and for a one-person shop that is a trap. One repo open, one mental model, done.

The one MCP server I bother with

I run exactly one MCP server: github. That is the only one that pays for itself for me. It lets the chat side read my issues and PRs without me copy-pasting, which is most of what I want from it. Copilot picks up MCP config from .vscode/mcp.json in the workspace. Mine is four lines plus a token.

{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${input:github_pat}"
      }
    }
  },
  "inputs": [
    {
      "id": "github_pat",
      "type": "promptString",
      "description": "GitHub PAT (repo + issues read)",
      "password": true
    }
  ]
}

One hook, format on save

People hear hook and picture some elaborate pipeline. Mine is a VS Code setting. When I save, Prettier runs. That is the entire automation budget for this build and I have never wanted more. Whatever Copilot suggested gets cleaned up the second I hit save, so the diff is always tidy and code review on my own PRs takes ten seconds.

{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "github.copilot.enable": {
    "*": true,
    "plaintext": false,
    "markdown": true
  },
  "github.copilot.editor.enableAutoCompletions": true
}

A normal session looks like this

I mostly drive from the CLI for git and let the editor handle suggestions, but Copilot has a terminal mode too and I lean on it for quick questions without leaving the shell. Here is roughly what a slice of my morning looks like.

What it is good at, what it is not

I am not going to pretend this setup is something it is not. It is light on agentic power. If you need a tool to plan a fifteen-file refactor and run for twenty minutes on its own, this is the wrong build and you should pay for that elsewhere. But for the work I actually do all day, it is hard to beat.

If you have never set Copilot up properly, the official getting-started walkthrough is genuinely good and short. I rewatched it when the MCP support landed because I had been doing the config the hard way.

18:33

And two links I actually keep open. The custom instructions doc is the page I send everyone, and the AGENTS.md standard is worth reading if you ever want the same instructions to work across more than one tool.

The short version

• One repo open, one model in your head. Resist the urge to split things.
• Keep copilot-instructions.md short. Three real rules beat thirty vague ones.
• One MCP server, github, only if you live in issues and PRs like I do.
• Format on save is the only automation you need on day one.
• Track cost per edit, not benchmark points. You are running a business, not a leaderboard.

That is the whole thing. No subagents, no orchestration, no token anxiety. If you want to try the exact build I run, it is on Setuproll as copilot-solo-cheap, and you can get the tool itself with code --install-extension GitHub.copilot. Install it, drop in the instructions file above, turn on format-on-save, and you are done. Go ship something.