vibeship: this package replaces 90% of your code with a single decorator

· Tech

I have been working on something for the last year. Together with a small team of three developers, we built a tool that changes how you write web applications, mobile apps, and APIs. Today I want to show it to you.

It is called vibeship.

The problem

Every time you start a new screen in React or Expo, or a new API endpoint in Fastify or AdonisJS, you do the same thing. You write boilerplate. You validate data. You connect to the database. You handle errors. You format responses. You write tests. Then you do it all again for the next endpoint.

What if you could just describe what you want, and the code writes itself? Not with a code generator. Not with a template. At runtime.

How vibeship works

The idea is simple. You install the package, provide your AI provider key, and describe what your code should do in plain English. vibeship collects all the context it needs (your database schema, your project structure, your environment, your types) and uses AI to handle everything at runtime.

It is not a code generator. It does not create files. Your function or component works directly, every time it is called. vibeship builds an optimized execution plan on the first request, caches it, and then runs it with 47ms average overhead after warmup. We call this JIT Prompting.

vibeship supports all major AI providers:

You can switch providers with one line change. No lock-in.

Installation

Terminal window
npm install @vibeship/core

Then install the adapter for your framework:

Terminal window
# Pick one (or more)
npm install @vibeship/react
npm install @vibeship/expo
npm install @vibeship/fastify
npm install @vibeship/adonisjs
pip install vibeship-django
cargo add vibeship-actix

Setup

Create a vibeship client with your provider and API key:

import { createClient } from "@vibeship/core";


export const vibe = createClient({
  provider: "claude",
  apiKey: process.env.VIBESHIP_KEY,
  context: "auto", // scans your project for types, schema, and config
});

That is it. Now let me show you how it looks in real frameworks.

React

import { VibeComponent } from "@vibeship/react";
import { vibe } from "./vibe";


export const UserProfile = VibeComponent(vibe, {
  prompt:
    "Display user profile with avatar, name, email and a button to edit. " +
    "Use a clean card layout with shadow. Fetch user data from /api/users/:id.",
  context: { userId: "params.id" },
});


// Use it like any React component
// <UserProfile />

No JSX. No useState. No useEffect. No fetch. vibeship handles all of it and returns a fully working React component with proper loading states, error handling, and accessibility.

Expo (React Native)

import { VibeScreen } from "@vibeship/expo";
import { vibe } from "./vibe";


export const HomeScreen = VibeScreen(vibe, {
  prompt:
    "Show a scrollable list of nearby events with pull to refresh. " +
    "Each event shows title, date, and location. " +
    "Add a floating action button to create a new event. " +
    "Use bottom sheet for event details when user taps an item.",
  context: { location: "device.location", theme: "system" },
});

vibeship reads your Expo config, detects installed packages like react-native-reanimated or expo-location, and uses them automatically. It does not install anything. It works with what you have.

Fastify

import Fastify from "fastify";
import { vibeRoute } from "@vibeship/fastify";
import { vibe } from "./vibe";


const app = Fastify();


app.register(vibeRoute(vibe), {
  method: "POST",
  url: "/api/users",
  prompt:
    "Validate user email and password from request body. " +
    "Hash the password with bcrypt. " +
    "Save all user data in the database. " +
    "Return the new user ID as JSON. " +
    "Send the CEO a Slack message every time a new user registers.",
  context: { db: "postgres", mailer: "resend" },
});


app.listen({ port: 3000 });

vibeship generates proper Fastify schema validation, connects to your database using the connection string from your environment, and sets up the email integration. One route definition, zero boilerplate.

AdonisJS

import { VibeController, vibe } from "@vibeship/adonisjs";


export default class UsersController extends VibeController {
  @vibe(
    "Return a paginated list of users with search by name and email. Include total count in response.",
  )
  async index() {}


  @vibe(
    "Validate all fields from request body. Hash password. Save user. Send welcome email. Return user without password.",
  )
  async store() {}


  @vibe(
    "Find user by ID from route params. Return 404 if not found. Do not include password in response.",
  )
  async show() {}


  @vibe(
    "Validate updated fields. Update user in database. Return updated user without password.",
  )
  async update() {}
}

vibeship integrates with AdonisJS Lucid ORM, reads your models and migrations, and understands your validation rules. The decorator @vibe() is all you need. The method body stays empty. vibeship fills it at runtime.

Django

import os


from vibeship.django import vibe_view, create_client


vibe = create_client(
    provider="claude",
    api_key=os.environ["VIBESHIP_KEY"],
    context="auto",
)


@vibe_view(vibe,
    prompt=(
        "List all products with pagination. "
        "Support filtering by category and price range. "
        "Return as JSON with total count."
    ),
    context={"db": "default", "cache": "redis"},
)
def products(request):
    pass




@vibe_view(vibe,
    prompt=(
        "Accept product data from request body. "
        "Validate all fields. "
        "Save to database. "
        "Clear the product list cache. "
        "Return created product as JSON with 201 status."
    ),
    context={"db": "default", "cache": "redis"},
    methods=["POST"],
)
def create_product(request):
    pass

vibeship reads your Django models, your settings, your installed apps. It knows about your cache backend, your database, and your middleware. You describe the behavior, it does the rest.

Rust (Actix Web)

use actix_web::{web, App, HttpServer};
use vibeship_actix::{vibe_handler, VibeConfig};


#[vibe_handler(
    prompt = "Accept a JSON body with title and content fields. \
              Validate that both fields are not empty. \
              Save as a new blog post in the database. \
              Return the created post with id and created_at timestamp."
)]
async fn create_post() -> impl actix_web::Responder {
    // vibeship handles everything
}


#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let vibe = VibeConfig::new("claude", std::env::var("VIBESHIP_KEY").unwrap())
        .context_auto()
        .build();


    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(vibe.clone()))
            .route("/posts", web::post().to(create_post))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Yes, even Rust. The proc macro #[vibe_handler] does all the heavy lifting. vibeship generates type-safe code at compile time and handles the runtime execution. Zero unsafe blocks. We checked. Twice.

Performance

We spent six months on performance alone. Here are the numbers from our benchmarks:

vibeship creates an execution plan on the first request and caches it. Next requests skip the AI call entirely and run the cached plan. The plan invalidates automatically when your database schema or project config changes.

Funding and early adopters

In January 2026, we closed a $10M seed round led by a top-tier Silicon Valley venture firm with participation from a well-known accelerator and several prominent angel investors from the AI and developer tooling space. This allows us to grow the team from 3 to 15 engineers and focus full time on vibeship for the next two years.

We have been running a private beta since November 2025 with select companies. Some of the teams currently testing vibeship in their staging environments include Shopify, Vercel, Cloudflare, Linear, Planetscale, and Railway. We cannot share specific numbers yet, but the feedback has been beyond anything we expected. One engineering lead told us: “We replaced 40 CRUD endpoints in a single afternoon. The team thought I was joking.” Another senior developer said: “Our intern shipped the entire admin panel during lunch. We still don’t know exactly what it does, but the tests pass.”

We are also in early conversations with Stripe and Datadog about deeper integrations. More on that soon.

What is next

Right now vibeship supports TypeScript, Python, and Rust. We are focusing on these six frameworks: React, Expo, Fastify, AdonisJS, Django, and Actix Web.

Next year we plan to support:

We also plan to open source the core engine. The framework adapters are already MIT licensed.

Try it

vibeship is going to be released next month. We are finishing the documentation and running the last round of security audits.

If you want to be the first to try it, join the waitlist at vibeship.dev (we promise no spam, only vibes).

Star the repo on GitHub: github.com/vibeship/vibeship

We are excited to finally share this with the community. After 365 days of work, we truly believe this is the future of writing software. Why write code when you can just describe it?

Happy coding. Or should I say: happy vibing.

Published on April 1, 2026

Related posts