Connect Your Agent to Real Tools
Stop Being the Copy-Paste Relay Between AI and Your Project
Before you spend another hour configuring n8n nodes, pause for a moment.
We know what it feels like to have the perfect workflow in mind — and then hit the setup wall.
Dragging nodes.
Reading API docs.
Testing connections.
Wondering if you’re doing this the “right way.”
After watching dozens of developers build the same workflows from scratch, we noticed something.
The hard part isn’t knowing what to automate. It’s the manual translation from idea to working n8n workflow.
That’s why we built Autom8n.
✨ From description to deployment in minutes
Tell us what you want to automate.
Get a complete n8n workflow — nodes configured, connections set, ready to deploy.
No more setup hell. No more node-by-node building.
Before you open another API doc or drag another node...
Hey there,
in the previous issueof this series, Build Your Agent’s Brain, you created your PROJECT.md, a brain that tells AI how your project works.
Here’s what it didn’t fix.
Let’s say you want to add a feedback table to your app: you open your AI tool and describe the feature; here’s what actually happens:
You describe your existing database schema to AI, because it can’t see it
AI writes the migration SQL, you copy it.
You must switch to Supabase, paste it, and run it.
Then you switch back to AI: you tell it the migration worked (or something similar).
AI asks what the updated schema looks like. You switch back to Supabase, copy the schema, switch back, and paste it.
AI writes the API route, then you copy it into your editor.
Then you realize the column names don’t match, because your description in step 1 was slightly off.
You start over from step 1.
Eight steps, three tools, two context switches, and one mistake that cost you twenty minutes. And this was one feature, one table… Imagine building an entire MVP like this.
You’re not leading AI, you’re a relay runner between tabs.
The blocker: AI writes code but can’t actually do anything. You’re still the bottleneck for every action, unfortunately.
What changes today: You connect your AI tool to your real stack: AI reads your database, runs migrations, checks deployments, directly. No more relay.
The transformation: Eight steps of copy-paste into one, simple command, real results.
The Blocker: You Are the Bottleneck
The PROJECT.md from Issue 01 solved the context problem: AI knows your project, your stack, your patterns.
But knowing and doing are different things.
Right now, it’s like AI has a brain and no hands: it can think about your project, it can write code for your project… But it can’t touch your project. Every action: running SQL, creating files, deploying code, checking logs, goes through you.
This is like hiring an architect who can design your house but can’t pick up a hammer. You end up doing all the physical work while they tell you what to do. That’s not a team, that’s extra overhead.
The fix? Give AI direct access to the tools it needs; that’s what MCP does.
What Is MCP (And Why It Matters Now)
MCP stands for Model Context Protocol. Ok, skip the spec, here’s what you need to know:
MCP lets your AI tool talk directly to external services: databases, deployment platforms, file systems, APIs. Anything with an MCP server becomes something your agent can use without you as the go-between.
Think of your PROJECT.md as a map: MCP is the car keys. The map tells AI where everything is.
The keys let it actually go there.
Three Connections That Unlock Everything
You could spend a week connecting every possible MCP server. Please, don’t.
For a solo developer shipping a side project, three connections unlock 90% of the value. Each one removes a specific class of copy-paste from your workflow.
Unlock 1: Your Database
What it removes: Describing your schema in every conversation, copy-pasting SQL between AI and your database dashboard, and getting wrong column names because your description was slightly off.
What it enables: AI reads your actual schema. Writes migrations against real tables. Runs them and verifies the result; catches its own mistakes before you do.
This is the highest-impact connection. Every feature you build touches data, and every conversation about your project involves table structures.
Connect this first.
Unlock 2: Your File System
What it removes: Copy-pasting code between AI and your editor, manually creating files in the right folders, and AI generating code that conflicts with files it can’t see.
What it enables: AI reads your actual codebase, creates files in the right place, modifies existing files, and runs your code. It stops working from memory and starts working from reality.
If you’re already using Claude Code or Cursor, you have this. They read your project files by default.
If you’re using ChatGPT or Claude on the web, this is what you’re missing.
Unlock 3: Your Deployment Platform
What it removes: Manually deploying after every change, switching to Vercel/Railway to check if something broke, and copying-pasting build logs back to AI when deploys fail.
What it enables: AI triggers, deploys, reads logs, checks status. The gap between “code works locally” and “code is live” shrinks from a chore to a command.
Everything else, Stripe, auth providers, and monitoring, is useful later. These three connections first.
Add the rest when you actually need them.
The Setup: Your First MCP Connection in 15 Minutes
We’re connecting your database. This is Unlock 1, the highest impact, the one you’ll use in every future issue of this series.
What You Need
A Supabase project (free tier works fine). If you use Neon, PlanetScale, or raw Postgres, the process is nearly identical; we’ll note differences.
Claude Code installed (free) OR Cursor with MCP support.
Your PROJECT.md from Issue 01 in your project root.
Step 1: Get Your Credentials
Go to your Supabase dashboard → Settings → API.
You need two things:
Project URL: https://YOUR_PROJECT_REF.supabase.co
Service role key: The long key under
service_role(not theanonkey)
If you don’t have a Supabase project yet, create one now. It takes literally two minutes to pick any name. You’ll use it immediately.
Step 2: Configure the MCP Server
Create or edit .mcp.json In your project root:
For Claude Code:
{
"mcpServers": {
"supabase": {
"command": "npx",
"args": [
"-y",
"@supabase/mcp-server-supabase@latest",
"--supabase-url",
"https://YOUR_PROJECT_REF.supabase.co",
"--supabase-service-role-key",
"YOUR_SERVICE_ROLE_KEY"
]
}
}
}Replace the URL and key with yours.
For Cursor:
Go to Settings → MCP Servers → Add Server. Use the same command and args from the config above.
Using something else?
Check if your tool supports MCP. If it does, use the same config structure. If it doesn’t, use Claude Code for connected tasks; it’s free and worth it.
Step 3: The First Read
This is the moment that changes how you think about AI tools.
Open your AI tool in your project directory and type this:
What tables exist in my database? Show me the full schema.Watch what happens.
AI doesn’t ask you to describe your database; it doesn’t guess at table names, it reaches into Supabase, reads your actual schema, and shows you what’s really there.
If you’ve been describing your tables manually in every AI conversation, this will feel like the first time you used autocomplete. Clearly evident in retrospect, but unfeasible to reverse.
If you got an error instead: check your project URL, make sure the service role key is correct (not the anon key), and verify the MCP server started. Most failures are credential typos.
Step 4: Do Something Real
Now use it. Same task from the intro, adding a feedback table:
Look at my current database schema and my PROJECT.md.
I need a new table for storing user feedback — a rating (1-5) and a text comment, linked to the user who submitted it.
Based on my existing schema patterns:
1. Create the migration SQL
2. Run the migration
3. Verify the table was created
4. Show me the updated schemaYes, no tab switching, no copy-pasting, no describing your schema from memory.
AI reads the real schema, matches your existing patterns (because it can see them), creates the table, runs the migration, and confirms it worked.
Same Task, Two Realities
Let’s put it side by side. The exact same request:
“add a feedback table with rating and comments.”
Without MCP:
You: “I have a users table with id, email, and created_at. I need a feedback table...”
AI: Writes SQL based on your description. Uses user_id as the foreign key, but your actual column is profile_id because you renamed it two weeks ago.
You: Copy the SQL, open Supabase, and paste. Error: foreign key doesn’t match. Go back to AI, explain the real column name. AI rewrites, you copied again. Paste again. It works. Go back to AI, tell it the table exists, and now ask for the API route. AI writes it using user_id again… because it still doesn’t know you renamed it.
Total time: 25 minutes, 6 tab switches, 2 errors.
With MCP:
You: “Add a feedback table with rating and comments, linked to the user.”
AI: Reads your schema, sees the column is profile_id. Write the migration with the correct foreign key, run it, and verify. Writes the API route using the correct column names because it just reads the real schema.
Total time: 2 minutes, 0 tab switches, 0 errors.
Same request, same words. Completely different experience.
The Prompt: Map Your Agent’s Full Reach
Your database is connected; now you need to know what else your agent can and can’t touch.
This prompt audits your entire setup and tells you exactly what to connect next:
You are a DevOps engineer who specializes in fast, minimal infrastructure for solo developers.
Your job: Audit my current project setup and tell me exactly which MCP connections I need to ship my MVP without being the copy-paste relay for every action.
Context:
- Read my PROJECT.md for project details and tech stack
- Read my current MCP configuration (check .mcp.json or equivalent)
- Check what tools and services my project already depends on
Tasks:
1. List every external service my project depends on (database, hosting, auth, payments, etc.)
2. For each service, report:
- MCP server available? (yes/no, with package name if yes)
- Priority: CRITICAL (blocks shipping), USEFUL (saves significant time), or LATER (nice to have)
- One-line setup instruction if available
3. Generate an updated .mcp.json that adds all CRITICAL connections to my current config
4. For any service without an MCP server, give me the fastest workaround (CLI tool, API key in env, direct SDK)
Rules:
- Only recommend connections that directly help me ship my MVP faster
- No experimental or unstable MCP servers — only official or well-maintained community packages
- If something takes more than 10 minutes to set up, flag it and explain why it's still worth it
- Prioritize based on what I'll actually use in the next 2 weeks, not theoretical completeness
- Do NOT suggest services I'm not already using
Output format:
1. Connection audit as a table (service | MCP available | priority | setup)
2. Updated .mcp.json file I can copy directly into my project
3. Ordered checklist: what to connect next and in what sequenceAfter running this, you’ll have a complete picture: what your agent can reach, what’s still blocked, and exactly what to do about it: in priority order.
Common Objections (And Why They’re Wrong)
“Isn’t it dangerous to give AI access to my database?”
Use a development database. Supabase lets you create branches, use that. Your service role key has permissions you control, and honestly, AI running a wrong migration on a dev database is less dangerous than you running one at 11 pm after copy-pasting from a chat window. At least AI checks the schema first.
“I don’t use Supabase.”
The pattern is identical for other databases. Neon has @neondatabase/mcp-server-neon. PlanetScale and raw Postgres have their own MCP servers. The config structure is the same, swap the package name and credentials. If your database doesn’t have an MCP server yet, the filesystem connection alone (Unlock 2) still removes half the copy-paste problem.
“My tool doesn’t support MCP.”
Claude Code is free and supports MCP natively, use it for connected work. Keep your other tool for everything else, you don’t need to switch completely, you just need one tool that can talk to your stack.
“This seems like a lot of setup for a side project.”
It’s 15 minutes: the feedback table example alone saved 23 minutes over the manual approach, and that was one feature. You’ll build dozens of features in your MVP, the math isn’t close.
Here’s what you learned today:
AI without access to your tools is just a text generator: it writes code you still have to move, run, and verify yourself; That’s overhead, not help.
Three connections unlock 90% of the value: database, file system, deployment platform. Everything else can wait.
MCP is a config file, not a paradigm shift: one JSON file in your project root, 15 minutes. That’s it.
The real unlock is eliminating relay work: every tab switch, every copy-paste, every “it worked, now write the next part” is friction that compounds across an entire project.
After Issue 01, AI understood your project.
After today, AI can act on your project.
Next week, we stop giving AI one-off requests and start giving it structured missions it can execute end-to-end. The difference between “build me a feedback form” and a spec that an agent can ship autonomously, without you hovering over every line.
Issue 03: Write a Spec Your Agent Can Execute.
But first: connect your database, run the schema query, watch AI read your actual tables. That’s the moment it stops feeling like a chatbot.
Now go give your agent some hands.
See ya next week,
— Ale & Manuel
PS... If you’re enjoying ShipWithAI, please consider referring this edition to a friend.
And whenever you are ready, there are 2 ways I can help you:
1. AI Side-Project Clarity Scorecard (Discover what’s blocking you from shipping your first side-project)
2. NoIdea (Pick a ready-to-start idea created from real user problems)



