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

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.

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.

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:

• Claude (Anthropic)
• Codex (OpenAI)
• Gemini (Google)
• Mistral
• Ollama (local models)
• LM Studio (local models)

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

npm install @vibeship/core

Then install the adapter for your framework:

npm install @vibeship/react
npm install @vibeship/expo
npm install @vibeship/fastify
npm install @vibeship/adonisjs
pip install vibeship-django

Create a vibeship client with your provider and API key:

import { createClient } from "@vibeship/core";
export const vibe = createClient({
  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.

import { VibeComponent } from "@vibeship/react";
import { vibe } from "./vibe";
export const UserProfile = VibeComponent(vibe, {
    "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

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.

import { VibeScreen } from "@vibeship/expo";
import { vibe } from "./vibe";
export const HomeScreen = VibeScreen(vibe, {
    "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.

import Fastify from "fastify";
import { vibeRoute } from "@vibeship/fastify";
import { vibe } from "./vibe";
app.register(vibeRoute(vibe), {
    "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.

import { VibeController, vibe } from "@vibeship/adonisjs";
export default class UsersController extends VibeController {
    "Return a paginated list of users with search by name and email. Include total count in response.",
    "Validate all fields from request body. Hash password. Save user. Send welcome email. Return user without password.",
    "Find user by ID from route params. Return 404 if not found. Do not include password in response.",
    "Validate updated fields. Update user in database. Return updated user without password.",

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.

from vibeship.django import vibe_view, create_client
    api_key=os.environ["VIBESHIP_KEY"],
        "List all products with pagination. "
        "Support filtering by category and price range. "
        "Return as JSON with total count."
    context={"db": "default", "cache": "redis"},
        "Accept product data from request body. "
        "Clear the product list cache. "
        "Return created product as JSON with 201 status."
    context={"db": "default", "cache": "redis"},
def create_product(request):

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.

use actix_web::{web, App, HttpServer};
use vibeship_actix::{vibe_handler, VibeConfig};
    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
async fn main() -> std::io::Result<()> {
    let vibe = VibeConfig::new("claude", std::env::var("VIBESHIP_KEY").unwrap())
    HttpServer::new(move || {
            .app_data(web::Data::new(vibe.clone()))
            .route("/posts", web::post().to(create_post))

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.

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

• First request (cold start): 340ms average
• Cached requests: 47ms average overhead
• Memory usage: 12MB base + 2MB per cached route
• Execution plan reuse rate: 94%

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.

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.

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:

• Vue and Nuxt
• Next.js (App Router and Pages Router)
• SvelteKit
• Laravel
• Rails
• Go (Gin and Echo)
• Spring Boot
• Flutter

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

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