Forem: Daniel Murrell

The Project Nursery

Daniel Murrell — Sat, 03 Jan 2026 20:29:55 +0000

Giving Cursor your own patterns to copy from

AI is pretty good at copying patterns. It’s not as good at inventing them. Give it a blank slate and ask for “a service layer,” and you’ll get something generic... probably fine, but not how you’d do it yourself. Point it at code that already works the way you like, and it’ll copy that instead.

This is obvious in hindsight, but it took me a while to discover. I kept starting new projects from scratch, describing what I wanted, getting okay-ish results. Meanwhile I had several working projects with patterns I’d refined over time just sitting there.

The Setup

The trick that made this click for me was symlinking my existing projects into the same parent folder as my new one:

mkdir ~/projects/nursery cd ~/projects/nursery ln -s ~/projects/flow-myna/mono flow-myna ln -s ~/projects/leveloh/mono leveloh ln -s ~/projects/auth-router auth-router mkdir spikelog # new project

Then I opened that folder in Cursor. Now when I say “build the auth context like flow-myna does it” or “use the same alembic migration setup as leveloh,” Cursor can see those folders/files. I’m not sure about other coding agent setups, but this trick made things easy to manage within Cursor.

One nice thing about symlinks specifically: Cursor will ask for confirmation before editing files in a symlinked folder. So your reference projects are protected... the AI can read them but won’t accidentally modify them, and if you do want them modified, you can just accept.

Your Projects as a Style Guide

I think of this folder as a nursery for new projects. The other projects aren’t templates... they’re just real working code that happens to be visible. They’ve diverged in different directions based on what they needed. Some have auth, some don’t. Some have payment processing, others are just static sites.

This is different from maintaining a boilerplate repo. With a boilerplate, you’re trying to anticipate what you’ll need and abstract it into something reusable. That’s a lot of upfront work, and six months later your preferences have changed anyway.

Here, there’s nothing to maintain. Each project is just itself. When I start something new, I tell the AI “look at how this other project handles X and do something similar.” It handles the copying, adapted to what I actually need this time.

Staying in Your Own Stack

I’ve found this works better than pointing the AI at some popular starter template. When it’s my code, I already know the patterns. I know why things are structured the way they are, where to look when something breaks.

With someone else’s boilerplate, you’re learning their conventions while trying to build something. The AI doesn’t know which parts are load-bearing and which are just preferences. It’s easier when everything is already familiar.

My stack for context: Next.js 14 with Tailwind on the frontend, FastAPI with PostgreSQL on the backend. Nothing unusual... just things I’ve used before and have working examples of.

The Result

I’d been sitting on a domain for a simple metrics service idea for years. A service where users POST a chart name and value, and charts appear automatically. It felt like a multi-week project, so I kept putting it off.

With this setup it took about 8 hours spread across a few days. The service is at spikelog.com if you want to take a look.

I don’t know if this generalises to everyone’s workflow, but the main idea seems sound: the patterns you’ve built up over time are worth reusing, and making them visible to the AI is an easy way to do that.

I'll be starting my new projects this way from now on.

--
More like this → dsmurrell.com

The best improvement I’ve made to my Cursor workflow

Daniel Murrell — Thu, 04 Dec 2025 19:35:37 +0000

tl;dr: let coding agents access runtime output

I’m pretty sure this isn’t novel, and I’m almost certain many people already do some flavour of this, but it’s been the single biggest unlock in my local AI-assisted development with Cursor, and it’s so simple I want to share it.

If your coding agent can’t see what your program is doing, it can’t debug it

Cursor doesn’t have some magical ability to read everything happening on your machine. Unless you explicitly expose your output, the agent is effectively blind.

When I let it see my program’s output, I found that it could solve problems that used to take me 30 minutes in about 30 seconds and free up my time to spend on other areas of the startup.

This post is me sharing how I let Cursor see my program’s outputs.

The problem:

Currently, my local dev setup has three moving parts:

a Python FastAPI backend
a React frontend
a Python FastAPI auth router which speaks to WorkOS to allow authentication

All three emit logs.
All three can fail independently.
All three can require debugging to get back up and running.

Cursor can run commands you ask for, or even come up with some that it thinks might be useful, but it cannot:

attach to a terminal window you opened yourself
read real-time stdout/stderr
watch a hot-reloading server
magically see your browser’s console logs

And when the agent tries to “fix” something by killing your running server or client, it destroys your whole hot-reloading setup. Now you have to put everything back up again just to continue. This can kill your productivity in a big way.

The unlock:

Coding agents can be more capable than you’d expect, and sometimes the best thing you can do is simply ask whether something you’re wondering about is possible. At one point, I asked: “Can you read something inside a screen session?”

To my surprise, Cursor told me:

If you run ’screen -X hardcopy’, I can read the output.

Then I asked Cursor if it could check the current screens that were running using screen -ls and find the last 50 lines of the server’s output. It did.

This gives the agent something to look at beyond just the code.

How I set it up:

I use runnem, a tiny tool I built for a different reason entirely: to remember your run setup and let you switch between multiple projects seamlessly.

It runs each service inside its own screen session, and that just so happens to make this unlock possible. But you can use anything:

standalone screen
tmux
Docker
setting up logging to a file on disk

The principle is universal.

With runnem, Cursor can:

list sessions with screen -ls
identify backend and frontend sessions
dump the relevant session’s output to disk without interrupting them
analyse logs while keeping everything up and ready to hot-reload on the next code change

My .cursor/rules snippet:

To guide the agent, I’ve added this to my .cursor/rules file.

If you need to check backend or frontend logs just ls all the active screens and then use a command like this:
“screen -S 94383.runnem-flow-myna-server -X hardcopy /tmp/backend_logs_200.txt && tail -200 /tmp/backend_logs_200.txt”
The screen with the ‘-server’ suffix is the backend and with the ‘-app’ suffix is the frontend.

Sometimes I still explicitly tell the agent to “check the logs using screen -ls”, and that’s enough for the agent to get into a loop that fixes errors until the server is running again.

Do you need runnem?:

No. Use any setup you like.

But runnem coincidentally makes this workflow very easy because:

each service has its own named screen
I run three services across two languages
the agent needs to cross-check all of them
everything stays running with hot-reload intact

I’ve been wanting an excuse to experiment with MCP, so I might try adding an MCP tool for runnem that lets Cursor talk to it more directly (for example, exposing “get backend logs” as a single tool call). But for now, this simple screen-based setup has been more than enough.

The final takeaway:
Once your agent can see your program’s output, it goes from:

editing files based on guesses

to something much more powerful:

responding to reality

If you’re running multiple services locally and want the agent to pull its weight:

Expose the output. Give it vision.
It’s a tiny setup change, but it has completely transformed how I work with AI.

Are other coding agents doing this already?

At the moment I don’t have the bandwidth to experiment with other coding agents. So there may well be setups like this included in those agents, or ways to nudge you into a similar workflow because it’s so powerful.

On the other hand, maybe they don’t build this in because the languages and frameworks they have to interact with are so varied.

I’d love to know in the comments what setup you use if you do things in a similar way! Especially if you’ve found a good way to give your agent visibility into the browser console logs that’s reliable and simple to setup.

A more detailed post can be found here: https://dsmurrell.com/articles/cursor-runtime-output

A small friction I finally removed

Daniel Murrell — Wed, 03 Dec 2025 22:33:31 +0000

Whenever I needed to track a number over time, I never even seriously looked at existing metrics tools. They all felt complicated at a glance... dashboards, exporters, configs.

So instead I kept doing this odd little workaround: store the numbers myself, then ask an LLM to generate a quick script to visualise them.

It worked.

But it was also tedious in a way that felt out of proportion with the problem.

What I really wanted was simpler:

send a number → see how it changes over time

So I stopped rebuilding the storage and the chart every time and turned that tiny pattern into a single endpoint instead. No dashboards. No setup. No decisions to make.

One number goes in, again and again. One chart quietly grows.

Because I already lean on AI for glue code, I also wrote a prompt that drops this kind of tracking straight into an existing codebase. It scans your project, suggests sensible metrics to track, and then wires in calls to a single API.

The rules are intentionally dull. Fire and forget, fail silently, aggregate anything noisy. Nothing clever. Nothing fragile.

I’m planning on keeping it free. The 1,000 datapoint rolling limit per chart is the trade-off that makes that possible.

If you end up wiring it into a side project, I’d genuinely love to see how you use this in the comments.

And if the problem resonates, the little thing I built from this is at spikelog.com