AI is taking the fun out of working: a developer’s honest take
A recent post on r/ArtificialInteligence struck a nerve with a lot of engineers. The author describes tackling a complex feature using Cursor and prompt chats end-to-end, barely pausing to think through the code first.
“It just feels boring more and more.”
The sentiment is familiar: AI is brilliant at removing toil, but it can also flatten the craft. When code generation becomes the default, some developers feel more like prompt operators than problem solvers.
Here’s what this means, why it matters in the UK context, and how to keep software engineering meaningful in the Copilot era.
From craftsmanship to “vibe coding”: what’s changing in the developer workflow
“Vibe coding” is the informal loop of iterating prompts, skimming generated diffs, and nudging the model until the feature works. It’s fast, and it often gets you to a working solution with less mental strain.
The trade-off is a subtle sense of detachment. You can ship more, yet understand less. The model carries the weight of structure and naming, while you become the editor-in-chief of a draft you didn’t write.
“I started prompting and chatting with Cursor… Basically, I vibe coded the whole thing.”
Used well, this is pair programming with a tireless assistant. Used uncritically, it can turn into copy-paste by proxy. The risk isn’t just bugs or hallucinations (fabricated but plausible-looking code); it’s losing the joy that comes from designing and understanding systems.
Why this matters for UK developers and teams
Beyond job satisfaction, there are practical UK considerations.
- Data protection and GDPR: If your prompts or code include personal data, architectural details, or secrets, you need to ensure a lawful basis for processing and proper safeguards. Review your provider’s data processing, retention, and training settings. The ICO’s guidance on AI and data protection is a good starting point.
- Procurement and cost: AI coding tools feel indispensable once adopted. Make sure your organisation has a clear policy on tool choice, pricing, and data residency, and that you can turn model training off where needed (vendor-specific).
- Skills and career development: If junior engineers skip design fundamentals and jump straight to generation, they risk shallow understanding. Senior engineers can find themselves in review fatigue instead of doing interesting design and research work.
Handled well, AI can free time for the rewarding bits: architecture, performance work, developer experience, and better user outcomes. Handled poorly, it turns coding into keystroke arbitrage.
Practical ways to keep software engineering meaningful in the Copilot era
Design first, then generate
Before you open the chat panel, write a short design note: the problem, constraints, interfaces, trade-offs, and risks. Even 10 minutes helps. Then ask the model to implement your design, not invent one. You remain the author; the model becomes the scribe.
Impose useful constraints
- Time-box “AI-off” discovery: e.g., 20 minutes to sketch APIs or data structures by hand.
- Require tests first for non-trivial code. Generate tests if you like, but decide what behaviour matters before implementation.
- Set architectural guardrails: approved libs, error-handling patterns, logging standards, and performance budgets. Feed these into prompts so the model follows your house style.
Keep human judgement where it matters
- Mandatory reviews for model-generated code, especially security-sensitive paths.
- Static analysis, linters, and coverage thresholds to catch subtle regressions.
- Threat modelling and performance profiling remain human-led disciplines. Use AI to draft, but make the judgement calls yourself.
Let AI do the genuinely boring bits
Lean into AI for scaffolding, migrations, boilerplate tests, documentation stubs, and glue code. Save energy for design, debugging, and domain modelling. For example, if you’re automating spreadsheet workflows, you can wire up ChatGPT with Google Sheets to remove repetitive ops tasks rather than outsource the interesting architecture work. See my walkthrough on connecting ChatGPT and Google Sheets using a custom GPT for a practical guide.
How to connect ChatGPT and Google Sheets (custom GPT)
Team practices that balance speed and satisfaction
Redefine “done” beyond “it works”
Update your Definition of Done to include clarity: readable code, rationale in the PR, tests that express intent, and recorded decisions about trade-offs. This reintroduces craftsmanship and makes AI-produced code traceable.
Rotate deliberate practice
Try “no-AI Friday” katas, small refactors, or bug hunts with a time-box. You won’t do this for everything, but periodic manual practice keeps skills sharp and reminds the team what good looks like without a model.
Grow domain expertise
Bring engineers closer to users and data. The more you understand the domain, the less boring the work feels, because your value shifts from typing code to shaping outcomes. AI can accelerate this by generating experiments and instrumentation, while you interpret the results.
Choosing tools and settings wisely
- Turn off training on your prompts and code if your provider allows it, especially for proprietary logic or personal data (vendor-specific).
- Redact secrets in prompts. Keep environment variables, keys, and internal URLs out of chats.
- Use local or self-hosted models where needed for privacy, or at least check data residency and retention options. Document the policy in your repo.
- Prefer smaller, testable changes from the model. Ask for a patch with rationale, not a full rewrite.
For tool specifics, see official docs for your chosen assistant. GitHub Copilot has documentation on configuration and privacy, and Cursor explains its capabilities and editor integrations.
GitHub Copilot docs | Cursor docs | ICO guidance on AI and data protection
A healthy mindset: you’re the engineer, AI is the tool
The Reddit author isn’t alone. Many of us feel the friction between speed and satisfaction. Instead of rejecting AI or surrendering to it, choose where it belongs in your process.
Use models to remove friction, not to remove thinking. Keep authorship of design, hold quality bar high, and invest your saved time in what makes engineering rewarding: understanding systems, serving users, and building things you’re proud to maintain.
Read the original discussion here: AI is taking the fun out of working
