The Vibe Coding Revolution

Software development was supposed to get easier. Instead, we got Kubernetes, Terraform, Docker Compose, CI/CD pipelines, infrastructure-as-code, and a thousand YAML files standing between an idea and a running application.

Vibe coding is the rejection of all that ceremony.

You open the Hoody Agent in your browser — or ssh hoody.com from any terminal, where the hosted Hoody CLI puts the same Agent one command away. You talk to an AI. You watch it build your app in real-time. You guide it with words, not configuration files. When it looks right, you ship it. The entire creative process happens in a conversation, and the infrastructure is just URLs that already work.

This is not a fantasy. This is what happens when every tool is an HTTPS endpoint, AI already speaks HTTP fluently, and the whole thing runs on servers you actually own. With a team that’s spent years building privacy-first infrastructure behind Hoody, your code stays yours.

Screenshot Needed Hoody Agent — vibe coding session with AI chat on left, code editor in center, live preview on right, and terminal at bottom

Vibe coding in the Hoody Agent: talk to AI, watch it build, guide when needed

---

What Is Vibe Coding?

Vibe coding is conversational development. You describe what you want in natural language. An AI agent writes the code, installs the dependencies, configures the services, runs the tests, and deploys the result. You watch, guide, and intervene when the AI needs human judgment.

All of this happens inside the Hoody Agent — a multi-pane view with your AI chat beside live terminals, files, and a display preview. Open it in a browser tab, or over ssh hoody.com — it is the same interface everywhere.

The term captures the experience precisely: you set the vibe, the AI does the coding.

What makes Hoody the ideal platform for this:

• hoody-agent — An autonomous coding agent controllable via HTTP
• hoody-code — VS Code running in your browser, no installation
• hoody-terminal — Shell access from anywhere, multiple instances
• hoody-display — Live preview of GUI applications in real-time
• hoody-exec — Scripts that become API endpoints instantly
• hoody-sqlite — Database accessible through HTTP calls
• Snapshots — Checkpoint at any moment, rollback in seconds

Every tool the AI needs is already a URL. Every tool you need to observe the AI is already a URL. The entire workflow lives in browser tabs.

---

The Workflow

1. Open Your Workspace

Open three browser tabs. That is your entire development environment:

Tab 1: https://PROJECT-CONTAINER-code-1.SERVER.containers.hoody.icu
       └── VS Code in your browser (watch AI write code here)

Tab 2: https://PROJECT-CONTAINER-terminal-1.SERVER.containers.hoody.icu
       └── Terminal (watch AI execute commands here)

Tab 3: https://PROJECT-CONTAINER-display-1.SERVER.containers.hoody.icu
       └── Live preview (watch your app update in real-time)

Or open the Agent (hoody-agent) and see everything in one window:

https://PROJECT-CONTAINER-agent-1.SERVER.containers.hoody.icu
       └── Chat, terminals, files, and preview in one multi-pane view

No local installation. No IDE plugins. No Docker running on your laptop eating your battery. Just URLs in a browser.

2. Launch Anything by Asking

Want a tool that is not installed yet? Just ask the agent — “run Jupyter”, “give me Postgres”, “start Redis” — and it launches it inside the container, resolving apps from Nix, pkgx, AppImage, or Docker/OCI images via hoody-run. No terminal ceremony, no install scripts, no docker-compose. Just say it and go. Keep the vibe.

3. Talk to the Agent

Open the agent interface and describe what you want:

CLI

# The `hoody agent` CLI exposes the agent service via `agent sessions prompt-sync`.
# You can also drive it directly via HTTP to the agent service URL.
# The session ID goes in the path; `?policy=auto_approve` runs headless.
curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync?policy=auto_approve" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Build a real-time dashboard that shows server metrics. Use React with Tailwind CSS for the frontend. Create a backend API with hoody-exec that reads system stats. Store historical data in SQLite. Auto-refresh every 5 seconds."
  }'

SDK

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://api.hoody.icu', token: process.env.HOODY_TOKEN });

// Using raw fetch to show the HTTP surface directly.
// The same endpoints are also available via client.agent.* in the SDK.
const response = await fetch(
  `https://${PROJECT_ID}-${CONTAINER_ID}-agent-1.${SERVER}.containers.hoody.icu/api/v1/agent/sessions/${SESSION_ID}/prompt:sync?policy=auto_approve`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: `Build a real-time dashboard that shows server metrics.
    Use React with Tailwind CSS for the frontend.
    Create a backend API with hoody-exec that reads system stats.
    Store historical data in SQLite.
    Auto-refresh every 5 seconds.`,
    }),
  }
);
const result = await response.json();

HTTP

curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync?policy=auto_approve" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Build a real-time dashboard that shows server metrics. Use React with Tailwind CSS for the frontend. Create a backend API with hoody-exec that reads system stats. Store historical data in SQLite. Auto-refresh every 5 seconds."
  }'

4. Watch It Build

Now watch your three browser tabs come alive:

In hoody-code (Tab 1): Files appear and change in real-time. The agent creates src/App.tsx, src/components/MetricsChart.tsx, api/metrics.ts. You see every keystroke, every import, every function definition as it happens.

In hoody-terminal (Tab 2): Commands execute. bun install react react-dom tailwindcss. bun create vite . --template react-ts. mkdir -p src/components. You see the agent think through the build process.

In hoody-display (Tab 3): Your app appears. First the Vite scaffold. Then the layout takes shape. Then the charts render. Then real data flows in. You are watching software materialize from a conversation.

Tip

This is the fundamental difference from traditional development. You are not writing code and waiting for feedback. You are watching code write itself and providing direction. The feedback loop is inverted.

5. Guide and Correct

The AI is good but not omniscient. Guide it:

CLI

# Continue the conversation via the agent CLI or direct HTTP.
# Reuse the same $SESSION_ID in the path to continue the same session.
curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "The chart colors are too similar. Use a red/green/blue palette. Also, add a dark mode toggle in the top right corner."
  }'

SDK

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://api.hoody.icu', token: process.env.HOODY_TOKEN });

// Using raw fetch to show the HTTP surface directly.
// The same endpoints are also available via client.agent.* in the SDK.
await fetch(
  `https://${PROJECT_ID}-${CONTAINER_ID}-agent-1.${SERVER}.containers.hoody.icu/api/v1/agent/sessions/${SESSION_ID}/prompt:sync`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: `The chart colors are too similar. Use a red/green/blue palette.
            Also, add a dark mode toggle in the top right corner.`,
    }),
  }
);

HTTP

curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "The chart colors are too similar. Use a red/green/blue palette. Also, add a dark mode toggle in the top right corner."
  }'

The agent modifies the code. The display updates. The conversation continues. You are pair programming with an AI, except neither of you had to install anything.

6. Snapshot at Checkpoints

When you reach a state you like, snapshot it:

CLI

# Lock in progress
hoody snapshots create -c $CONTAINER_ID \
  --alias "dashboard-v1-looks-good"

SDK

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://api.hoody.icu', token: process.env.HOODY_TOKEN });

await client.api.containers.createSnapshot(CONTAINER_ID, {
  alias: 'dashboard-v1-looks-good',
});

HTTP

curl -X POST "https://api.hoody.icu/api/v1/containers/$CONTAINER_ID/snapshots" \
  -H "Authorization: Bearer $HOODY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"alias": "dashboard-v1-looks-good"}'

Now continue experimenting. Tell the agent to try something ambitious. If it goes wrong, restore the snapshot in seconds. Risk is free when rollback is instant.

7. Share and Ship

When you are satisfied, share the URL:

# Your app is already live at its container URL
https://PROJECT-CONTAINER-display-1.SERVER.containers.hoody.icu

# Or create a clean production alias
hoody proxy create \
  --container-id $CONTAINER_ID \
  --program display --index 1 \
  --alias "my-dashboard"

From conversation to production URL. No build pipeline. No deployment configuration. No waiting for DNS propagation. The app was already running — you just pointed a clean domain at it.

---

The “Twitter Clone in 2 Hours” Paradigm

The phrase has become shorthand for a new era of development. Here is what it actually looks like on Hoody:

Hour 1: The Conversation

You:    "Build a social media app like Twitter. Users can post short messages,
         follow other users, and see a feed. Use React, Tailwind, and SQLite."

Agent:  [Creates database schema: users, posts, follows tables]
        [Scaffolds React app with Vite]
        [Implements authentication with session tokens]
        [Builds the feed algorithm]
        [Creates the post composer component]
        [Wires up the API endpoints via hoody-exec]

You:    "The feed should show newest first. Add a character counter
         that turns red at 280 characters."

Agent:  [Modifies feed query to ORDER BY created_at DESC]
        [Adds character counter component with conditional styling]

Hour 2: Polish and Ship

You:    "Add profile pages with a follow/unfollow button.
         Make it look professional -- use a card-based layout."

Agent:  [Creates /profile/[username] route]
        [Implements follow/unfollow toggle]
        [Redesigns layout with card components]
        [Adds loading skeletons]
        [Writes automated tests]

You:    "Perfect. Snapshot this and create a production alias."

Agent:  [Creates snapshot: twitter-clone-v1]
        [Creates proxy alias: my-twitter.node-us.containers.hoody.icu]

Two hours. One conversation. A working application with a production URL. The AI wrote the code, configured the database, set up the routing, and deployed. You provided creative direction.

Note

This is not about replacing developers. It is about eliminating the 90% of development time spent on configuration, deployment, and infrastructure — the parts that have nothing to do with building the product.

---

Why HTTP Makes This Work

Vibe coding on traditional infrastructure does not work. Here is why:

Traditional setup before you can start: Install Node.js. Install a database. Configure a reverse proxy. Set up SSL. Write a Dockerfile. Create a docker-compose.yml. Configure environment variables. Set up a CI/CD pipeline. Configure DNS. Wait for provisioning.

Hoody setup before you can start: Create a container.

Everything else is already HTTP. The terminal is HTTP. The file system is HTTP. The database is HTTP. The browser preview is HTTP. The deployment is HTTP. The agent orchestrating all of it speaks HTTP natively.

When the AI says “install this package,” it makes an HTTP call to the terminal. When it says “create this table,” it makes an HTTP call to SQLite. When it says “deploy this,” the code is already running — it was live the moment the file was saved.

The entire feedback loop is HTTP. That is why vibe coding works on Hoody and feels painful everywhere else.

---

Live Preview Updates Automatically

Because hoody-display serves the actual desktop environment of your container, your preview updates in real-time as the agent modifies files. There is no “rebuild and refresh” cycle:

1. Agent writes src/App.tsx via hoody-agent’s file operations
2. Vite’s hot module replacement detects the change (it is running as a daemon)
3. hoody-display reflects the updated UI immediately
4. You see the change in your browser tab within milliseconds

This is the same experience whether you are on your laptop, your phone, or a tablet at a coffee shop. The container is the source of truth. Every display is just a window into it.

---

Collaborative Vibe Coding

Share the workspace URL with a collaborator. They see everything you see. In real-time.

You:           Talking to the agent, guiding the build
Collaborator:  Watching in hoody-display, typing corrections in hoody-terminal
Agent:         Building what you both describe

Three participants. Three perspectives. One container. No screen sharing, no “can you see my cursor,” no lag. Just URLs that multiple people can open simultaneously.

This is not theoretical multiplayer. This is the natural consequence of HTTP. When every service is a URL, sharing is just sending the URL. Everyone is already in.

---

The Vibe Coding Safety Net

AI-generated code is confident code. It compiles. It runs. And sometimes it is subtly, catastrophically wrong. Hoody’s snapshot system makes this acceptable:

Risk	Mitigation
Agent installs bad packages	Restore snapshot
Agent deletes important files	Restore snapshot
Agent breaks the database	Restore snapshot
Agent introduces security vulnerability	Restore snapshot, review code
Agent rewrites working code incorrectly	Restore snapshot, try different prompt

The pattern: Snapshot before every major change. Experiment freely. Restore if needed. The cost of failure approaches zero.

---

Switching Modes

hoody-agent ships with several built-in agents (modes) that match different phases of vibe coding:

• general — The default agent. Writes and modifies code, executing tools based on configured permissions.
• plan — A planning-oriented agent that works through explore/plan/execute phases, producing a detailed plan before implementing.
• explore — Read-only research mode for understanding a codebase without modifying it.

Switch modes mid-conversation to match what you need:

CLI

# Switch the live session to the plan agent, then ask it to design.
hoody agent sessions set-chat-agent --id $SESSION_ID --agent plan --realm global
curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync?policy=auto_approve" \
  -H "Content-Type: application/json" \
  -d '{"text": "Plan the architecture for an e-commerce platform. Do not write code yet — just outline the components, data models, and API surface."}'

# Once the plan looks good, switch back to the general agent and start coding.
hoody agent sessions set-chat-agent --id $SESSION_ID --agent general --realm global
curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync" \
  -H "Content-Type: application/json" \
  -d '{"text": "The architecture looks good. Now implement it."}'

SDK

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://api.hoody.icu', token: process.env.HOODY_TOKEN });

// Using raw fetch to show the HTTP surface directly.
// The same endpoints are also available via client.agent.* in the SDK.

const sessionURL = `https://${PROJECT_ID}-${CONTAINER_ID}-agent-1.${SERVER}.containers.hoody.icu/api/v1/agent/sessions/${SESSION_ID}`;

// Switch the live session to the plan agent, then ask it to design.
await fetch(`${sessionURL}/agent`, {
  method: 'PATCH',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ agent: 'plan' }),
});
await fetch(`${sessionURL}/prompt:sync?policy=auto_approve`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    text: 'Plan the architecture for an e-commerce platform. Do not write code yet — just outline the components, data models, and API surface.',
  }),
});

// Once the plan looks good, switch back to the general agent and start coding.
await fetch(`${sessionURL}/agent`, {
  method: 'PATCH',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ agent: 'general' }),
});
await fetch(`${sessionURL}/prompt:sync`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    text: 'The architecture looks good. Now implement it.',
  }),
});

HTTP

# Switch the live session to the plan agent, then ask it to design.
curl -X PATCH "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/agent" \
  -H "Content-Type: application/json" \
  -d '{"agent": "plan"}'
curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync?policy=auto_approve" \
  -H "Content-Type: application/json" \
  -d '{"text": "Plan the architecture for an e-commerce platform. Do not write code yet — just outline the components, data models, and API surface."}'

# Once the plan looks good, switch back to the general agent and start coding.
curl -X PATCH "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/agent" \
  -H "Content-Type: application/json" \
  -d '{"agent": "general"}'
curl -X POST "https://$PROJECT_ID-$CONTAINER_ID-agent-1.$SERVER.containers.hoody.icu/api/v1/agent/sessions/$SESSION_ID/prompt:sync" \
  -H "Content-Type: application/json" \
  -d '{"text": "The architecture looks good. Now implement it."}'

---

Hooks: Safety Guardrails for Vibe Coding

Vibe coding means the AI has the wheel. That is liberating — and occasionally terrifying. hoody-agent’s hooks give you safety nets that run underneath every session, without interrupting the creative flow.

Hooks fire on session and tool lifecycle events — SessionStart, UserPromptSubmit, PreToolUse, PostToolUse and more — and each runs a shell command you supply, wired to its event in plain JSON configuration. Add a UserPromptSubmit hook that injects “CRITICAL: Never execute rm -rf, DROP TABLE, or git push —force without asking first” into every turn. Add a PreToolUse hook matching bash that fires a notification whenever the agent is about to run a shell command — or blocks the call outright. Add a Stop-time hook that pings Slack when a session ends unexpectedly.

The safety net is always on, even when you are in the flow. You set the vibe, the AI does the coding, and your hooks keep it within bounds.

---

From Vibe to Production

Vibe coding is not just for prototypes. The output is real code running on real infrastructure. When you are ready for production:

1. Snapshot the final state — Your insurance policy
2. Create a proxy alias — Clean URL for the world
3. Set proxy permissions — Control who can access what
4. Set up hoody-cron — Automated backups and maintenance
5. Configure hoody-daemon — Ensure processes restart on failure

Every step is an HTTP call. The vibe becomes the product without a single “deploy” step. The code was already running. You just decided it was done.

---

Any Provider, Any Model

The AI driving your vibe coding session is not locked in. Hoody supports 75+ providers — Claude, GPT-4o, Gemini, Mistral, Groq, local Ollama, any OpenAI-compatible endpoint. Switch models mid-session by swapping the profile in hoody-agent’s settings. Run today’s hottest model, tomorrow’s better one, or your own fine-tuned local model when the task calls for privacy. One config change, same workflow. See Hoody AI for the provider list.

---

What’s Next

• Deploying Autonomous AI Agents — Go deeper into agent capabilities
• Building a Full-Stack Application — Step-by-step app construction
• Multiplayer by Default — Collaborative vibe coding with your team
• VS Code in Browser — Customize your coding environment