The Vibe Coding Revolution

Software development was supposed to get easier. What arrived instead was 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 that ceremony.

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

This works because every tool is an HTTPS endpoint, AI already speaks HTTP fluently, and the whole thing runs on servers you own, so your code stays yours.

Screenshot Coming Soon 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 vibe coding is

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. The name is literal: you set the vibe, the AI does the coding.

All of this happens inside the Hoody Agent, a multi-pane view with the 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 pieces Hoody brings to this workflow:

• hoody-agent: an autonomous coding agent controllable via HTTP
• hoody-code: VS Code running in your browser, with nothing to install
• hoody-terminal: shell access from anywhere, with multiple instances
• hoody-display: live preview of GUI applications in real time
• hoody-exec: scripts that become API endpoints as soon as they are saved
• hoody-sqlite: a database accessible through HTTP calls
• Snapshots: a checkpoint at any moment, rollback in seconds

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

---

The workflow

Step 1: Open the workspace

The development environment is three browser tabs:

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

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

Tab 3: https://PROJECT-CONTAINER-display-1.SERVER.containers.hoody.com
       └── 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.com
       └── Chat, terminals, files, and preview in one multi-pane view

There is nothing to install locally, no IDE plugin to add, and no Docker on your laptop eating its battery. The environment is URLs in a browser.

Step 2: Launch tools by asking

If a tool is not installed yet, ask the agent for it: “run Jupyter”, “give me Postgres”, “start Redis”. It launches the tool inside the container, resolving apps from Nix, pkgx, AppImage, or Docker/OCI images via hoody-run. There are no install scripts or docker-compose files involved; asking is the entire procedure.

Step 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.com/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.com', 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.com/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.com/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."
  }'

URL

?

One request, one link

cURL runs inside your container and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

Slashes, colons and braces pass through as they are. The one character you must encode is an & inside a value, which happens when the wrapped URL carries its own query string. Left raw it ends the value early, and the rest is read as cURL's own parameters, so you get a 200 on a request you did not make.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Sends this build prompt to the session as a single link. policy=auto_approve means the agent runs its tool calls without pausing for approval.

Copy

https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-CONTAINER_ID-agent-1.SERVER.containers.hoody.com/api/v1/agent/sessions/SESSION_ID/prompt:sync?policy=auto_approve&method=POST&json={"text":"Build%20a%20real-time%20dashboard%20that%20shows%20server%20metrics.%20Use%20React%20with%20Tailwind%20CSS%20for%20the%20frontend.%20Create%20a%20backend%20API%20with%20hoody-exec%20that%20reads%20system%20stats.%20Store%20historical%20data%20in%20SQLite.%20Auto-refresh%20every%205%20seconds."}&response=transparent

Step 4: Watch the build

The three browser tabs now show the work in progress:

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 watch every keystroke, import, and 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, then the charts, then real data flowing in. You are watching software take shape from a conversation.

Tip

The feedback loop is inverted compared with traditional development: instead of writing code and waiting for feedback, you watch the code being written and supply the direction.

Step 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.com/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.com', 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.com/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.com/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."
  }'

URL

?

One request, one link

cURL runs inside your container and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

Slashes, colons and braces pass through as they are. The one character you must encode is an & inside a value, which happens when the wrapped URL carries its own query string. Left raw it ends the value early, and the rest is read as cURL's own parameters, so you get a 200 on a request you did not make.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Sends this follow-up as a single link. Reuse the same SESSION_ID as the first request so it lands in the same conversation instead of starting a new one.

Copy

https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-CONTAINER_ID-agent-1.SERVER.containers.hoody.com/api/v1/agent/sessions/SESSION_ID/prompt:sync&method=POST&json={"text":"The%20chart%20colors%20are%20too%20similar.%20Use%20a%20red/green/blue%20palette.%20Also,%20add%20a%20dark%20mode%20toggle%20in%20the%20top%20right%20corner."}&response=transparent

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

Step 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.com', token: process.env.HOODY_TOKEN });

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

HTTP

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

URL

?

One request, one link

cURL runs inside your container and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

Slashes, colons and braces pass through as they are. The one character you must encode is an & inside a value, which happens when the wrapped URL carries its own query string. Left raw it ends the value early, and the rest is read as cURL's own parameters, so you get a 200 on a request you did not make.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Creates the snapshot from a single link, without opening a terminal.

Copy

https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://api.hoody.com/api/v1/containers/CONTAINER_ID/snapshots&method=POST&bearer_token=TOKEN&json={"alias":"dashboard-v1-looks-good"}&response=transparent

The link carries a credential and executes with it, so it is as sensitive as the credential itself — and it passes through the cURL service's request log on the way, not just the target's. Share it only where you would share the secret, and prefer a delegated token with minimal permissions and an expiry: see API tokens.

Then keep experimenting, and tell the agent to try something ambitious. If it goes wrong, restoring the snapshot takes seconds, so a failed experiment costs almost nothing.

Step 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.com

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

That is the whole path from conversation to production URL. There is no build pipeline, no deployment configuration, and no DNS propagation to wait for; the app was already running, and the alias points a clean domain at it.

---

A Twitter clone in two hours

The two-hour Twitter clone has become the stock example for this style of development. Here is what it 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.com]

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

Note

None of this replaces developers. It removes 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 does not work on traditional infrastructure, and the reason is setup:

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, and wait for provisioning.

Hoody setup before you can start: create a container.

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

When the AI says “install this package,” it makes an HTTP call to the terminal. “Create this table” is an HTTP call to SQLite. “Deploy this” requires no call at all, because the code went live the moment the file was saved.

The entire feedback loop runs over HTTP, which is what lets one agent drive it end to end.

---

Automatic preview updates

Because hoody-display serves the actual desktop environment of your container, the 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

The experience is the same on your laptop, your phone, or a tablet at a coffee shop. The container is the source of truth; every display is a view into it.

---

Collaborative vibe coding

Share the workspace URL with a collaborator and 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. There is no screen sharing, no “can you see my cursor,” and no lag: the same URLs are open in several browsers at once. Multiplayer here is a consequence of HTTP, because when every service is a URL, sharing means sending the URL, and everyone who has it is already in.

---

Recovery from agent mistakes

AI-generated code is confident code: it compiles, it runs, and sometimes it is still subtly, catastrophically wrong. Hoody’s snapshot system makes that risk 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

Snapshot before every major change, experiment freely, and restore if needed; a failed experiment costs one restore.

---

Agent modes

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

• general: the default agent. It writes and modifies code, executing tools based on configured permissions.
• plan: a planning-oriented agent that works through explore/plan/execute phases and produces 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.com/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.com/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.com', 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.com/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.com/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.com/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.com/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.com/api/v1/agent/sessions/$SESSION_ID/prompt:sync" \
  -H "Content-Type: application/json" \
  -d '{"text": "The architecture looks good. Now implement it."}'

URL

?

One request, one link

cURL runs inside your container and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

Slashes, colons and braces pass through as they are. The one character you must encode is an & inside a value, which happens when the wrapped URL carries its own query string. Left raw it ends the value early, and the rest is read as cURL's own parameters, so you get a 200 on a request you did not make.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Each step of the plan-then-build sequence as its own link: switch to plan, ask it to design, switch back to general, then ask it to implement. Run them against the same session, in order.

Copy

# Switch to plan
https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-CONTAINER_ID-agent-1.SERVER.containers.hoody.com/api/v1/agent/sessions/SESSION_ID/agent&method=PATCH&json={"agent":"plan"}&response=transparent

# Ask it to plan
https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-CONTAINER_ID-agent-1.SERVER.containers.hoody.com/api/v1/agent/sessions/SESSION_ID/prompt:sync?policy=auto_approve&method=POST&json={"text":"Plan%20the%20architecture%20for%20an%20e-commerce%20platform.%20Do%20not%20write%20code%20yet%20%E2%80%94%20just%20outline%20the%20components,%20data%20models,%20and%20API%20surface."}&response=transparent

# Switch to general
https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-CONTAINER_ID-agent-1.SERVER.containers.hoody.com/api/v1/agent/sessions/SESSION_ID/agent&method=PATCH&json={"agent":"general"}&response=transparent

# Ask it to implement
https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://PROJECT_ID-CONTAINER_ID-agent-1.SERVER.containers.hoody.com/api/v1/agent/sessions/SESSION_ID/prompt:sync&method=POST&json={"text":"The%20architecture%20looks%20good.%20Now%20implement%20it."}&response=transparent

---

Hooks

Vibe coding gives the AI a lot of autonomy. hoody-agent’s hooks give you checks 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. A PreToolUse hook matching bash can fire a notification whenever the agent is about to run a shell command, or block the call outright. A Stop-time hook can ping Slack when a session ends unexpectedly. The checks stay on for the whole session, so the agent stays within the bounds you set even when you are deep in the flow.

---

From vibe to production

The output of a vibe coding session is real code running on real infrastructure, not a throwaway prototype. When you are ready for production:

1. Snapshot the final state to keep a restore point
2. Create a proxy alias for a clean public URL
3. Set proxy permissions to control who can access what
4. Set up hoody-cron for automated backups and maintenance
5. Configure hoody-daemon so processes restart on failure

Every step is an HTTP call, and there is no separate “deploy” step: the code was already running, and at some point you decided it was done.

---

Provider and model choice

The AI driving your vibe coding session is not locked in. Hoody supports 75+ providers, including Claude, GPT-4o, Gemini, Mistral, Groq, local Ollama, and any OpenAI-compatible endpoint. Switch models mid-session by swapping the profile in hoody-agent’s settings; the workflow stays the same. When a task calls for privacy, run your own fine-tuned local model. See Hoody AI for the provider list.

---

What’s Next

• Deploying Autonomous AI Agents: agent capabilities in more depth
• 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