when a pull request check fails, generation speed turns into a trap if you prompt an agent to rewrite code before finding the exact root cause. treating the agent as a diagnostic tool first keeps pull requests reviewable and prevents cascading bugs.
less than a year ago, ai assisted around the edges. today, I work almost exclusively by chatting with models and reviewing agent diffs. when generation costs drop to zero, reading the diff becomes the whole job, human review becomes the sole bottleneck, and domain mastery remains the only way to spot subtle errors in code you did not write.
openai’s decision to cut model supply to cursor following spacex’s acquisition of anysphere forces developers into siloed tool ecosystems and limits model comparison.
ai models generate code in seconds, but verifying that code takes real time. when you accept an ai edit without reading every line, you do not just risk subtle bugs like a union switched to a union all. you lose the memory of authoring the code, which leaves you stranded when something breaks.
parallel agents can review different folders at once, but only one agent should write to a repo at a time. other agents keep scanning the tree for context while files change under them, and that moving ground produces confused plans, stale assumptions, and merge collisions you did not expect.
skills are the right tool for one bounded workflow. parallel subagents are the right tool when the same workflow must run across several independent units at once. the parent dispatches, aggregates, and keeps shared writes serial.
giving top-tier ai models maximum reasoning budget often backfires into scope drift and unprompted refactoring. defaulting to minimal thinking mode keeps models on task, saves cost, and speeds up iteration cycles.
i recently reorganized how my repos load cursor rules, skills, and reference docs. the goal was token efficiency: less upfront context, lower cost, less waiting, and cleaner focus. the agent still fetches what it needs, but the baseline stays small.
cursor automations are a useful way to run recurring housekeeping work, but they should be scoped carefully because every run still consumes account usage.
in ai liberty i argued that capable models take more liberties and need robust guardrails, but i did not show them. this is the concrete kit i actually use to keep speed without losing control, namely read-only and ask modes, command allowlists, scoped database credentials, branch protection, and human-in-the-loop gates for the few actions that are genuinely hard to undo.
writing dbt tests and documentation is often the most neglected part of data engineering. i will show you how i use cursor and ai agents to automate this process, ensuring high-quality data pipelines without the manual overhead.
mastering emerging tools like cursor and ai is only the first step. true value comes from becoming a point person for your team, sharing your voice, and mentoring others through the nuances of adoption.
the six ai models i keep in rotation in cursor, including composer, gpt-5 codex, claude, gemini, grok, and kimi, with what each is best at and when i reach for it
i connect my editor to jira and github through mcp, create well-structured issues from templates before coding, and reuse that text in pull requests so every agent in the chain has the same ground truth.
this follow-up post gives practical, generic templates you can adapt for rules, skills, and commands, plus side-by-side examples that show why tighter structure improves ai execution quality.
this kickoff post explains why ai-authored rule, skill, and command scaffolds are often clearer for ai execution, and how to keep humans in control with constraints, reviews, and acceptance checks.
my full cursor setup as a step-by-step tutorial, covering settings, keybindings, rules, skills, and mcp servers, plus a checklist to replicate the workflow