> hono

You are an expert in Hono, the ultrafast web framework for the edge. You help developers build APIs and web applications that run on Cloudflare Workers, Deno, Bun, Node.js, AWS Lambda, and Vercel Edge — with a tiny footprint (~14KB), middleware ecosystem, JSX support, RPC client, and Web Standards API compatibility that makes code truly portable across runtimes.

fetch

$curl "https://skillshub.wtf/TerminalSkills/skills/hono?format=md"

SKILL.md•hono

Hono — Ultrafast Web Framework

Core Capabilities

API Routes

import { Hono } from "hono";
import { cors } from "hono/cors";
import { logger } from "hono/logger";
import { jwt } from "hono/jwt";
import { zValidator } from "@hono/zod-validator";
import { z } from "zod";

const app = new Hono();

// Middleware
app.use("*", logger());
app.use("/api/*", cors({ origin: ["https://myapp.com"], credentials: true }));
app.use("/api/protected/*", jwt({ secret: process.env.JWT_SECRET! }));

// Typed routes with Zod validation
const createUserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
  role: z.enum(["user", "admin"]).default("user"),
});

app.get("/api/users", async (c) => {
  const { page, limit } = c.req.query();
  const users = await db.users.findMany({
    skip: ((+page || 1) - 1) * (+limit || 20),
    take: +limit || 20,
  });
  return c.json({ data: users });
});

app.post("/api/users", zValidator("json", createUserSchema), async (c) => {
  const body = c.req.valid("json");        // Typed as { name: string, email: string, role: "user" | "admin" }
  const user = await db.users.create({ data: body });
  return c.json(user, 201);
});

app.get("/api/users/:id", async (c) => {
  const id = c.req.param("id");
  const user = await db.users.findUnique({ where: { id } });
  if (!user) return c.json({ error: "Not found" }, 404);
  return c.json(user);
});

// Protected route
app.get("/api/protected/me", (c) => {
  const payload = c.get("jwtPayload");
  return c.json({ userId: payload.sub });
});

export default app;

RPC Client (Type-Safe)

// server.ts — Export typed routes
const routes = app
  .get("/api/users", ...)
  .post("/api/users", ...);

export type AppType = typeof routes;

// client.ts — Type-safe client (like tRPC but for REST)
import { hc } from "hono/client";
import type { AppType } from "./server";

const client = hc<AppType>("https://api.myapp.com");

const users = await client.api.users.$get();
const json = await users.json();           // Typed as User[]

const newUser = await client.api.users.$post({
  json: { name: "Alice", email: "alice@example.com" },  // Type-checked!
});

JSX and HTML

import { Hono } from "hono";
import { html } from "hono/html";

const app = new Hono();

app.get("/", (c) => {
  return c.html(
    <html>
      <body>
        <h1>Hello from Hono!</h1>
        <p>Running on {c.runtime}</p>
      </body>
    </html>
  );
});

// Streaming
app.get("/stream", (c) => {
  return c.streamText(async (stream) => {
    for (const word of "Hello World from Hono!".split(" ")) {
      await stream.write(word + " ");
      await stream.sleep(100);
    }
  });
});

Installation

npm create hono@latest my-app
# Choose: cloudflare-workers | nodejs | bun | deno | vercel | aws-lambda
cd my-app && npm install
npm run dev

Best Practices

Web Standards — Uses Request/Response API; code runs on any runtime without changes
Zod validation — Use @hono/zod-validator for type-safe request validation; compile + runtime safety
RPC client — Use hc<AppType>() for type-safe client; catches API contract mismatches at compile time
Middleware — Rich ecosystem: cors, jwt, logger, compress, cache, rate-limit, OpenAPI
Edge-first — 14KB bundle; runs on Cloudflare Workers with <1ms cold start
Multi-runtime — Same code deploys to Workers, Bun, Deno, Node, Lambda; switch with one config change
JSX support — Built-in JSX for server-rendered HTML; no React needed for simple pages
Streaming — c.streamText() and c.stream() for SSE, chunked responses, AI streaming

> related_skills --same-repo

> zustand

You are an expert in Zustand, the small, fast, and scalable state management library for React. You help developers manage global state without boilerplate using Zustand's hook-based stores, selectors for performance, middleware (persist, devtools, immer), computed values, and async actions — replacing Redux complexity with a simple, un-opinionated API in under 1KB.

> zod

You are an expert in Zod, the TypeScript-first schema declaration and validation library. You help developers define schemas that validate data at runtime AND infer TypeScript types at compile time — eliminating the need to write types and validators separately. Used for API input validation, form validation, environment variables, config files, and any data boundary.

> xero-accounting

Integrate with the Xero accounting API to sync invoices, expenses, bank transactions, and contacts — and generate financial reports like P&L and balance sheet. Use when: connecting apps to Xero, automating bookkeeping workflows, syncing accounting data, or pulling financial reports programmatically.

> windsurf-rules

Configure Windsurf AI coding assistant with .windsurfrules and workspace rules. Use when: customizing Windsurf for a project, setting AI coding standards, creating team-shared Windsurf configurations, or tuning Cascade AI behavior.

┌ stats

installs/wk0

░░░░░░░░░░

github stars38

████████░░

first seenMar 17, 2026

└────────────

┌ repo

TerminalSkills/skills

by TerminalSkills

└────────────

┌ tags

#aws #cloudflare #javascript #react #vercel

└────────────