Want to revolutionize your business with AI? Check SSW's Artificial Intelligence and Machine Learning consulting page.
Vibe coding empowers non-developers to build software using AI agents. However, without proper foundation and structure, vibe coding can result in unmaintainable code that fails "the bus test" – meaning if you were hit by a bus tomorrow, no one else could understand or maintain your code.
AI should be your first choice when developing software. For example, website functionality changes are often much faster to implement by describing what you want in natural language than by hand-coding the solution yourself. This approach, called "vibe coding", is more efficient for most development tasks.
However, AI isn't infallible. It becomes especially risky when you're one-shotting an entire application rather than making focused, incremental changes. Every AI-generated change should still be reviewed, tested, and approved before it reaches production.
Since the release of GitHub Copilot, we have witnessed a dramatic evolution in how developers work within their IDE. It started with a simple AI autocomplete, then a chat function, and now we are in an agentic gold mine. AI has now been integrated deeply into IDEs with products like Visual Studio Code and Cursor, embedding an even deeper level of AI integration within a developer's workflow.
AI coding assistants have become essential tools for developers, but many rely solely on IDE extensions like GitHub Copilot or Cursor. While these are valuable, AI CLI tools offer unique advantages that can significantly boost your productivity and code quality.
CLI-based AI tools provide a focused, distraction-free environment with full terminal context, making them ideal for complex tasks, debugging, and working with entire codebases.
Anecdotally, developers have noticed that CLI tools often produce higher-quality, more accurate results than their IDE counterparts - possibly due to better context handling and fewer UI constraints.
Typing is the bottleneck now. An agent will happily take 3 times the context you'd ever bother typing: your constraints, your edge cases, the things you explicitly don't want. Almost nobody gives it that. Typing a paragraph is a chore, so you send a one-liner and get a one-liner's quality back.
Dictation fixes it. Most people quit before they find a tool that works, because the first ones you try are slow, clip the start of your sentence, and can't spell your own product names.
Until recently, the only ways to change how a coding agent behaved were its instructions file (AGENTS.md, CLAUDE.md, etc) and, on most agents, shell-command hooks. If you wanted the agent to display additional information, or to stop doing something it kept doing, you waited for the vendor to ship it.
That has changed. Every major agent now has lifecycle hooks (Claude Code, Codex, GitHub Copilot, Gemini CLI and Cursor), Claude Code has a scriptable status line, and in October 2026 Anthropic shipped mods, TypeScript functions that run inside Claude Code and can rewrite what it does or draw new UI.
AI coding assistants like Cursor and GitHub Copilot are incredibly powerful, but they work best when they understand your project's specific architecture, coding standards, and common tasks. Without this context, they may suggest patterns that don't align with your codebase.
AGENTS.mdis an agreed-upon standard between all the big AI players, replacing things like .cursorrules and copilot_instructions.md.
Your AI agent refactors a method and leaves the old one behind. You tell it to delete what it replaced. Next week, in another repository, it does the same thing and you tell it again. Some corrections have nothing to do with the project. They are about how you expect any agent to work on any code.
If these corrections stay in your head, you repeat them forever. If you copy them into every project's AGENTS.md, you maintain the same paragraph in ten places.
A new developer joins the project and starts their AI coding agent. It asks for permission to run the build. Then the tests. Then the linter. They click "allow" forty times on the first day, and by the afternoon they click it without reading. Meanwhile nothing stops the agent from opening the .env file, because the instruction "never read secrets" is only a sentence in AGENTS.md.
Instructions tell an agent what you want. They don't stop it. What the agent is actually allowed to do is decided by its settings file, and most teams leave that on each developer's machine.
Every developer has a few instructions that only make sense on their machine. Your API runs on a different port. You use your own test account. You start the backend yourself. These notes often end up in the shared AGENTS.md or CLAUDE.md, where they are noise for everyone else. Or they stay out of any file, and you repeat them in every chat.
One large AGENTS.md creates problems as a project grows. Agents use space in the context window for instructions that don't apply to the current work. Scoped rule files address this — they load only when an agent works on files in specific locations.
AGENTS.md is the cross-tool standard for AI coding instructions. Claude Code and GitHub Copilot code review both read it directly now, so you don't need a CLAUDE.md or .github/copilot-instructions.md copy of it. Skills are the one gap left: Claude Code only loads skills from .claude/skills/, so symlink that folder to .agents/skills/.
When AI assistants (e.g. GitHub Copilot, Claude, ChatGPT) perform development tasks, they sometimes create temporary files, scripts, or intermediate outputs. By default, they might use system temp directories like /tmp, /var/tmp, or the user's home directory. This creates several problems: files become hard to find, they're outside version control, and cleanup becomes unpredictable.
Configuring AI assistants to work exclusively within the repository boundaries ensures all work is visible, properly managed, and easy to clean up.
GitHub Copilot CLI is incredibly powerful, but giving AI deep access to your terminal and file system can be concerning. When you use features like --allow-all-tools - which approves all actions - Copilot can execute commands on your behalf, which means one wrong suggestion could have serious consequences.
Running Copilot CLI in a secure Docker container provides the best of both worlds: powerful AI assistance with strict security boundaries that limit the "blast radius" of any potential mistakes.
Sometimes a bug report simply describes a problem. Other times, it includes a suspected cause: "The Orders page is slow because the new caching layer is broken." The reporter might be a customer, a teammate, or an AI agent that mined the logs overnight. When a report names a cause, it mixes what they saw with what they think caused it.
If you plan the fix from that suspected cause without checking it, you fix the theory, not the bug. AI-written issues make this worse. They often read like finished diagnoses, complete with a suspected file and line number, and it is tempting to skip straight to the code.
Measure twice, cut once. Before any non-trivial change, always create and review a plan with AI. An AI plan is only as good as the human review it receives. The Discuss step in the Plan → Discuss → Implement → Review workflow is where your domain knowledge and judgment provide the most value. See the SSW rule on AI-assisted development.
Reviewing the plan is what separates professional AI-assisted development from vibe coding.
You spend three days on a big feature and open a pull request with 40 changed files. Your reviewer reads it and says "this should have been built on the existing notification module". They are right, and now the choice is between a rewrite and merging something the team doesn't want.
The pull request is the most expensive place to find a design problem. By then the code is written, the tests are written, and everyone is reluctant to throw the work away.
You’re in the zone: the AI is pumping out code, you’re copy-pasting at light speed, and everything seems to work… until a weird edge case hits production, a security scanner lights up, or your team can’t explain the “magic” function anyone merged last week.
Vibe coding is awesome - as long as you add guardrails.
When working with AI agents, a common bottleneck is the human review loop. If you ask an agent to "refactor this class" and it introduces a syntax error, you have to spot it and tell the agent to fix it. This manual feedback loop is slow, unscalable, and wastes your time.
You finish a bug fix, then ask the same AI agent session to write a new feature. The agent still carries every file, error, and failed attempt from the bug fix. It gets distracted by old details, forgets your newer instructions, and every message costs more than it should.