Vesi Staneva for SashiDo.io

Posted on Feb 19

Artificial Intelligence Coding Is Turning Into Vibe Working: What Still Breaks

#ai #programming #devops #backend

Something bigger than faster autocomplete is happening. In the last year, artificial intelligence coding moved from “help me write this function” to “take this objective and run with it.” The same behavior is now showing up outside engineering, where people brief AI agents once, then iterate on outputs instead of building them manually.

If you have been riding the vibe coding wave, this shift feels familiar. You stay in flow, you describe intent in plain language, and the tool fills in the boring parts. The difference is that “vibe working” pushes that pattern into documents, analysis, planning, and operations. It also exposes a blunt reality: the bottleneck is no longer writing code. It is making AI-produced work reliable, auditable, and safe enough to ship.

Here’s the first major insight we see across teams and solo builders. The moment an agent does multi-step work, you stop needing “more prompts” and start needing “more system.” That system is usually state, identity, permissions, storage, background execution, and an API surface you can trust.

If you want a quick way to de-risk early experiments, start by keeping cost and infra decisions reversible. A 10-day trial with predictable limits helps you move fast without committing early. You can check the current trial and entry plan details on our Pricing page.

What People Mean by Vibe Working (And Why It Shows Up Now)

Vibe working is the workplace version of vibe coding. The idea is simple. Instead of “point and click” workflows, you brief an AI agent with intent, context, and constraints, then review what it produces.

In software, IBM describes vibe coding as prompting AI to generate code, then refining later, which naturally prioritizes experimentation and prototyping before optimization. That “code first, refine later” mentality is captured in IBM’s overview of vibe coding.

Now the same pattern is being pushed into mainstream productivity tools. Microsoft has framed this as a new human-agent collaboration pattern inside Office, where Agent Mode can turn plain-language requests into spreadsheets, documents, and presentations through iterative steering. Their product direction is spelled out in Vibe Working: Introducing Agent Mode and Office Agent in Microsoft 365 Copilot.

The reason it “suddenly works” is not magic. It is a mix of better reasoning, longer context windows, and agent tooling that supports multi-step plans. The reason it “suddenly breaks” is also predictable. Once agents touch real data and real users, you inherit the same problems every production system has always had.

The Hidden Trade: From Manual Effort to Operational Risk

Vibe working often feels like free leverage. You trade time spent producing artifacts for time spent directing and reviewing them.

But the trade is not purely economic. It is a shift in failure modes.

When a human writes a report, most mistakes are local. A wrong number, a missing citation, a flawed assumption. When an agent produces and updates reports, pulls data, emails stakeholders, and triggers workflows, mistakes become systemic. The errors propagate, the provenance becomes fuzzy, and the blast radius increases.

This is why governance and security frameworks matter even for indie builders. The NIST AI Risk Management Framework is useful here, not because it tells you how to prompt better, but because it forces you to think about measurement, monitoring, and accountability across the lifecycle. Start with the landing page for the NIST AI Risk Management Framework (AI RMF 1.0) and treat it as a checklist for “what needs to exist before I trust an agent with real work.”

At the app layer, the OWASP community has also cataloged common ways LLM-powered apps fail. The OWASP Top 10 for Large Language Model Applications is a practical read because it maps directly to what vibe working introduces: prompt injection risks, sensitive data exposure, insecure plugin-style actions, and weak boundaries between “suggestion” and “execution.”

When Vibe Working Works, And When It Fails

The most useful way to think about vibe working is not “AI replaces tasks.” It is “AI changes which constraints matter.”

It tends to work best when the task has a clear objective, the inputs are constrained, and the outputs can be reviewed cheaply. It struggles when the task is ambiguous, the inputs are messy, or the outputs trigger irreversible actions.

Here is a simple field-tested way to decide if a workflow is ready for agentic automation.

Good candidates are workflows where you can validate outcomes quickly, like drafting a spec from an outline, summarizing known documents, generating boilerplate UI, or producing an initial dashboard view. These map well to the “best AI tools for coding” category too, because the review loop is fast.

Bad candidates are workflows with hidden coupling and real-world consequences, like payroll decisions, account deletions, production config changes, mass emailing, or changing permissions. The agent may be “right” most of the time, but one failure is too expensive.

If you are a solo founder building a prototype, a practical threshold is this. Once you put an AI feature in front of more than 100 to 1,000 real users, you should assume you need auditability, rate limits, safe retries, and a way to reproduce what the system did.

Artificial Intelligence Coding in the Agent Era: What Changes for Builders

In classic artificial intelligence coding, you implement models, data pipelines, and inference endpoints. In vibe coding, you prompt assistants to write the code.

In vibe working, you are effectively building systems that supervise semi-autonomous work. That changes what “done” means.

The patterns that matter most are surprisingly non-glamorous:

You need a clear identity model, so the agent is not acting as “whoever asked last.” You need state, so multi-step work can resume, retry, and explain itself. You need storage, because artifacts are not just text. They are files, logs, and attachments. You need background execution, because real work rarely fits inside a single synchronous request. And you need real-time visibility, because debugging agents is mostly about seeing what happened, not guessing.

When people search “how to add backend to AI app,” this is usually what they mean, even if they phrase it as “my agent keeps forgetting things” or “my demo works but I cannot ship it.”

The Copilot Confusion: GitHub Copilot vs Microsoft Copilot

A lot of teams conflate “Copilot” with a single product, then get surprised by mismatched expectations.

GitHub Copilot is built for developers inside editors and code review workflows. It is best thought of as an AI pair programmer that produces and refactors code in context. The most direct reference point is the official GitHub Copilot documentation, which focuses on IDE integration, suggestion workflows, and developer experience.

Microsoft Copilot is broader. It is designed for productivity work across Microsoft apps, where the outputs are spreadsheets, documents, decks, and summaries. Microsoft’s own starting point is the Microsoft Copilot help center, which frames Copilot as a cross-app assistant rather than an IDE-first coding tool.

In practice, the “github copilot vs microsoft copilot” question is less about which is better AI for coding, and more about which environment you are automating. If your work product is code, GitHub Copilot is the native fit. If your work product is Office artifacts and enterprise workflows, Microsoft Copilot is the more direct match. Many builders use both.

The missing piece, for both, is still the same. You need a backend to persist decisions, manage users, enforce permissions, and turn suggestions into safe actions.

The Backend Reality Check: Agents Need Memory, Not Just Context

A lot of agent demos rely on context windows as a substitute for memory. That works until it does not.

Context is what you paste in. Memory is what the system stores, retrieves, and audits over time. If you are building an AI product, you eventually need both.

For example, if you are building a support assistant, you need to track user identity, consent, conversation history, escalations, and attachments. If you are building an AI content tool, you need drafts, version history, and publishing status. If you are building an agent that runs a weekly workflow, you need schedules, retries, and a place to persist intermediate outputs.

This is where a managed backend matters because it removes the “I need to learn DevOps to ship a demo” tax.

With SashiDo - Backend for Modern Builders, we focus on the boring infrastructure that keeps agentic apps from collapsing in production. Each app comes with a MongoDB database and CRUD API, a complete user management system with social logins, file storage backed by AWS S3 with a built-in CDN, serverless functions you can deploy in seconds, realtime via WebSockets, and background jobs you can schedule and manage.

If you want to go deeper on implementation details, our documentation and developer guides are the best place to understand how Parse-based backends map to modern web and mobile apps.

A Practical Build Path: From Vibe Coding Prototype to Vibe Working System

If you are using a no code AI app builder, or you are prototyping fast with prompts and generated code, you can still apply a “production readiness ladder.” You do not need to do everything on day one. You do need to do the next right thing before usage ramps.

Start by making sure your AI feature has a stable interface and clear boundaries. That means defining what the agent is allowed to do, what it can only suggest, and what it must never touch without human confirmation.

Then add identity and access control early, even if you only have a handful of users. The moment you demo to investors or early customers, authentication stops being “enterprise stuff” and becomes table stakes.

Next, persist state outside the model. Store conversation summaries, tool outputs, and decisions as structured data. This is the difference between an agent that “feels smart” and a product that can be debugged.

Then make long-running work explicit. If an agent needs to poll a feed, send push notifications, or generate a weekly report, it should run as a background job with retries and monitoring. Otherwise, you end up with fragile timeouts and ghost failures.

Finally, plan for scale earlier than you think. You do not need to over-engineer, but you should know how you will scale if your demo suddenly hits 10,000 users after a launch.

We have a practical walkthrough for this “from idea to deployed backend” phase in SashiDo’s Getting Started Guide and the follow-up Getting Started Guide Part 2. They are written for builders who want to ship quickly without turning infrastructure into the project.

Cost Predictability Is Part of Reliability

Vibe working encourages experimentation. That is good. The trap is that experimentation can also produce unpredictable infrastructure bills, especially when agents generate more requests than humans would.

The most common cost shock we see is not model spend. It is the compound effect of retries, polling, file storage growth, and “just one more integration.” That is why you should always tie agent workflows to quotas and monitoring, and choose a backend plan where you can see limits and overages up front.

We keep pricing and limits transparent and up to date on our Pricing page, including the free trial. If you scale beyond your base plan, you can also tune performance with compute options. Our deep dive on Engines and how scaling works explains when you actually need more horsepower and how costs are calculated.

Reliability Patterns That Matter More Than Better Prompts

If you remember one thing from the vibe working shift, make it this. Prompting is interface design. Reliability is systems design.

These are the patterns we recommend putting in place before you call something “ready,” especially if you plan to build an AI app that interacts with real users:

Make actions explicit: separate “draft” from “send,” and “suggest” from “apply,” so an agent cannot accidentally cross the line.
Log intent and outcomes: store what the agent was asked to do, what it did, and what data it touched. This is the only way to debug non-deterministic behavior.
Treat files as first-class artifacts: reports, exports, and attachments need storage with stable URLs, access control, and delivery performance.
Design for retries: agent workflows fail for mundane reasons like timeouts and rate limits. Your system should retry safely without duplicating side effects.
Use realtime where humans supervise: when a person is steering an agent, streaming status updates prevents “black box waiting” and makes review faster.

If your product includes mobile engagement, also think about notification pipelines early. Push is often the first “real world” signal that your backend is behaving. We have written about high-volume delivery patterns in Sending Millions of Push Notifications, and about uptime architecture in High Availability and Zero-Downtime Deployments. Both topics become relevant surprisingly early once an agent is running unattended.

Tooling Choices: Avoid Lock-In, Keep Leverage

For indie hackers and solo founders, tool choice is rarely about ideology. It is about speed now and optionality later.

If you are weighing managed backends, the practical questions are. Can I ship auth, data, files, functions, realtime, and jobs without building a platform team. Can I migrate if I must. Can I predict my spend. Can I recover quickly when something breaks.

If you are comparing alternatives like Supabase, Hasura, AWS Amplify, or Vercel, we recommend focusing on your actual constraints. If your AI product needs a Parse-compatible backend and you want to avoid piecing together five services, compare the trade-offs directly. For reference, here is our breakdown of SashiDo vs Supabase and SashiDo vs AWS Amplify.

Artificial Intelligence Coding Languages That Fit Vibe Working

Vibe working changes what you value in a language. You want fast iteration, a strong ecosystem, and clean ways to integrate APIs, data stores, and background tasks.

For most AI-first products, Python remains the most common choice for model-adjacent work because of its ecosystem and community gravity. But in production, a lot of the glue ends up in JavaScript or TypeScript, because web apps, dashboards, and serverless functions often live there.

What matters is not winning a language debate. It is choosing a stack where you can ship a reliable surface area quickly, then optimize later. If your AI feature is primarily “agent plus workflow,” you can keep the model layer separate and focus your application layer on auth, data, files, jobs, and realtime updates.

Conclusion: Vibe Working Is Real, but Systems Still Decide Who Ships

Vibe working is not a fad label. It is a reasonable description of what happens when AI agents can execute multi-step work and humans shift into steering, review, and decision-making.

The builders who win with artificial intelligence coding in this era will not be the ones with the fanciest prompts. They will be the ones who build boring reliability around agent behavior. Identity, state, audit logs, safe actions, predictable costs, and a backend that does not require a DevOps detour.

If you are moving from prompt demos to real users, it helps to stand up the backend foundations early. You can explore SashiDo’s platform to see how database, auth, functions, jobs, realtime, storage, and push fit together in a deploy-in-minutes workflow.

When you are ready to move from an impressive prototype to a product you can safely iterate on, deploy with SashiDo - Backend for Modern Builders and keep your focus on the experience, not the infrastructure. Check the current free trial and plan limits on our Pricing page, then use our Getting Started guides to ship a working backend in an afternoon.

Frequently Asked Questions

How Is Coding Used in Artificial Intelligence?

In artificial intelligence coding, the “coding” is often the orchestration layer. You wire data ingestion, evaluation, and guardrails around a model, then expose it through APIs and UIs. In vibe working scenarios, coding is also used to persist agent state, enforce permissions, and make multi-step actions observable and reversible.

Is AI Really Replacing Coding?

AI is replacing some manual typing and boilerplate, but it is not replacing the need to design systems. As agents do more end-to-end work, the hard part shifts to specifying constraints, validating outputs, and building reliable infrastructure around actions and data access. Coding becomes more about integration, safety boundaries, and operations.

How Much Do AI Coders Make?

Compensation varies widely by region and seniority, but the premium is usually tied to impact, not buzzwords. People who can ship AI features into production tend to earn more than those who only prototype, because they can handle reliability, security, and monitoring. Roles that blend backend engineering with LLM integration often price highest.

How Difficult Is Artificial Intelligence Coding for a Solo Builder?

Prototyping is easier than ever because you can use best ai for coding tools to generate scaffolding quickly. Production is still hard if you do not plan for auth, data modeling, and long-running workflows. The difficulty usually spikes when you add real users, persistent state, and background jobs, not when you write the first prompt.

DEV Community