Where Cursor Stops and My Judgment Begins

The line between helpful and harmful

I use Cursor a lot. It is very good at filling in the boring middle: boilerplate components, wiring props, nudging TypeScript into shape.

It is also completely blind to the parts of my work that are not in the repo.

On a recent stretch of projects, Cursor kept offering elegant, confident solutions that would have failed for reasons it could not possibly know: old CMS quirks, office conventions, security boundaries, brand tone, and a cardiologist’s email from 2019.

The interesting part was not where the AI was worse at code. Often it was better. The interesting part was where my job stopped being about code at all.

FibrXL: perfect recursion, wrong universe

For a FibrXL project I was building a product configurator. Cursor looked at the data model and proposed a clean, recursive tree component for nested categories.

The problem lives nowhere in the codebase. It lives in a 2019 email thread and in Nick’s head: the client’s CMS occasionally flattens nested categories in ways that are not predictable from the schema. The API says “tree,” production behaves like “a sometimes-tree, sometimes-pile.”

Cursor assumed the data was trustworthy. The component it generated was logically correct and would have broken the first time real data came through.

My judgment was not better than Cursor at writing React. It was better at knowing which assumptions were dangerous. The right move was to design for corruption: defensive parsing, guards against impossible states, and a UI that fails soft instead of hard when the hierarchy collapses.

Cursor can scaffold a component. It cannot know that a CMS integration from five years ago lies to you on Tuesdays.

Ideebv: clean code vs Emile’s filing system

At Ideebv, all the design work lives on a Synology NAS. There is a folder convention that predates my employment and cuts across three departments. It is not pretty, but it is how people find things when a deadline is close.

I wrote about this earlier in Why I Still Hand‑Code Every Hover State.

When I asked Cursor to help script a batch processor for client assets, it happily invented a fresh structure under /assets/clients/. Tidy, modern, and completely detached from the way the studio actually works. Shipping that script as-is would have scattered files across a new tree that only the code understood.

Cursor optimizes for technical clarity. It sees a chance to normalize paths and reduce special cases. I optimize for not breaking Emile’s muscle memory when he goes looking for a PDF in a folder he has opened hundreds of times.

The right solution was uglier: accept the historical structure, encode the weirdness in the script, and document it so the next person understands why /Clients/OLD/ZZZ_archive is still part of the pipeline. That is not something you infer from a single open file. It is a social constraint.

Key2Control: reusable helper, invisible leak

On a Key2Control portal, Cursor suggested importing a generic helper from an internal utilities package. The function itself was harmless. The import path was not.

Pulling in that module would have exposed a sibling file containing hardcoded API keys for a staging environment. The AI saw reusable code and a shorter implementation. I saw a risk of credentials ending up in a client bundle where they did not belong.

This is the kind of thing you only become paranoid about after you have shipped something you later had to apologize for. It is not a lint rule, and it is not obvious from the diff. You have to know which parts of your own codebase are radioactive.

Cursor has no sense of blast radius. It only sees an import it can resolve.

My job in that moment was not to write a clever helper. It was to say: no, we duplicate this tiny bit of logic here, because the alternative is dragging a bag of secrets into the browser.

Gate Seal: neutral layout, no point of view

On a Gate Seal product page, Cursor did what it does often: it produced a competent layout. Centered content, reasonable spacing, sensible breakpoints.

More on this in my article Ethics Of AI In Frontend: Who Owns Your UI Components?.

What it could not decide was whether the page should feel maritime or militaristic. That decision already existed in Aris’s visual language: heavier contrast, industrial typography, and a sense of weight rather than speed.

Cursor’s default is neutral corporate. That is fine for a design system, but useless when the point is to make a product feel like it belongs on a ship’s hull instead of in a cloud dashboard.

The final 10% of polish was not about CSS tricks. It was about taste, continuity, and context. I had to override the AI’s centrist instincts and push the page toward the specific tone we had established elsewhere.

Models have been trained on a lot of UI, but not on the internal stories a brand tells itself about why it looks the way it does. They cannot see the moodboard on the wall or hear the client say, “It should feel heavy, not fast.”

My heart is not in the training data

The most personal example did not involve a client at all. I asked Cursor for a fitness tracking dashboard component. It generated the usual calorie-burn widget and heart-rate zones you see in many health apps.

None of that applies cleanly to my body after a quadruple bypass in 2019. My max heart rate is capped by a cardiologist’s directive, not by a formula. The safe zone for me is not the safe zone for a generic user in a dataset.

The code Cursor produced was medically naive because it had to be. It cannot know the contents of my medical file or the context of that surgery. It can only generalize from the majority.

Read also The Schema.org Markup Every Client Site Should Ship With.

I caught the problem because I live in the edge case the training data smooths over. That is not a clever coding insight. It is a reminder that typical is a statistical construct, not a person.

What I actually use Cursor for

Across these projects, a pattern keeps repeating. Cursor is useful for:

• Scaffolding components once I have chosen a safe shape
• Filling in obvious glue code and tests
• Translating intent I already trust into implementation

It struggles with:

• Undocumented constraints
• Office politics encoded in folder trees
• Security boundaries that are not explicit in code
• Choosing a visual point of view
• Edge cases like a heart that disagrees with its default math

The boundary is simple: Cursor can move fast inside the box I draw for it. Drawing that box is still my job.