New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

New Deno App

by jackfranklin in jackfranklin/dotfiles

Scaffold a new Deno 2 + Hono + Deno KV + Eta + HTMX app with password auth and PWA support.

MITAuto-check: notesDevelopment

Install New Deno App

skills CLI
$ npx skills add jackfranklin/dotfiles --skill new-deno-app -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jackfranklin/dotfiles new-deno-app --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jackfranklin/dotfiles.git skills-src && mkdir -p .claude/skills && cp -r skills-src/claude/skills/new-deno-app .claude/skills/new-deno-app && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
new-deno-app
GitHub stars
255
Token cost
~3.6k tokens
SKILL.md length
673 words
Files
1
Skills in repo
20
Repo updated
First seen
Licence
MIT

At a glance

Scaffold a new Deno 2 + Hono + Deno KV + Eta + HTMX app with password auth and PWA support.

  • Works in 6 steps: Gather information → Determine project directory → Create project → …
  • The user wants to create a new personal web app following this stack
  • SKILL.md covers Step 1: Gather information, Step 2: Determine project…, Step 3: Create project and Step 4: Create placeholder…, plus 2 more sections
  • Calls git, gh and deno; reaches cdn.jsdelivr.net; needs APP_PASSWORD

What it does

New Deno App is an agent skill from jackfranklin/dotfiles. Scaffold a new Deno 2 + Hono + Deno KV + Eta + HTMX app with password auth and PWA support. Use when the user wants to create a new personal web app following this stack.

Its SKILL.md is about 3.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development. It works with Deno and Hono. The repository describes itself as: My dotfiles for my dev environment, compromising of tmux, vim, zsh and git. The licence is MIT.

When your agent uses it

  • The user wants to create a new personal web app following this stack

Example prompts

  • “/new-deno-app”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Gather information
  2. Determine project directory
  3. Create project
  4. Create placeholder icon files
  5. Initialize git and create GitHub repo
  6. Final instructions

What it can do on your machine

Read from SKILL.md and the folder at commit bfc6291. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh
    • deno

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • cdn.jsdelivr.net

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • APP_PASSWORD

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

New Deno App loads about 3.6k tokens when it runs. Until then it costs about 46 tokens; SKILL.md has 673 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~46
When it runs · the whole SKILL.md, loaded when a task matches
~3.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:402
    .env

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from jackfranklin/dotfiles at commit bfc6291, republished under its MIT licence (© jackfranklin). 673 words, ~3,635 tokens.

Download SKILL.mdSave it as .claude/skills/new-deno-app/SKILL.md (or your agent's skills folder).
name
new-deno-app
description
Scaffold a new Deno 2 + Hono + Deno KV + Eta + HTMX app with password auth and PWA support. Use when the user wants to create a new personal web app following this stack.
disable-model-invocation
true

You are scaffolding a new personal web app. These apps follow a strict set of conventions:

  • Deno 2 runtime, no build step — TypeScript runs natively
  • Hono for routing (from JSR: jsr:@hono/hono@^4)
  • Deno KV for the database (built-in to Deno)
  • Eta for server-side HTML templates (from JSR: jsr:@eta-dev/eta@^3)
  • HTMX 2 for frontend interactivity (CDN, no npm)
  • PicoCSS classless for styling (CDN, no npm)
  • Single shared APP_PASSWORD env var for auth — SHA-256 hash in a session cookie
  • PWA: manifest.json + minimal pass-through service worker
  • Deployed to Deno Deploy via GitHub push to main

Step 1: Gather information

Always ask the user for all of the following interactively — do not attempt to parse $ARGUMENTS:

  1. app-name — kebab-case, used for directory name and GitHub repo name
  2. Display Name — full title shown in browser tab and manifest (e.g. "Book Tracker")
  3. Short name — ≤12 characters, shown on Android home screen under the icon (e.g. "Books")
  4. Description — one sentence describing what the app does
  5. Theme color — hex color for PWA theme/background (default: #ffffff)
  6. Emoji — single emoji used as the app logo in the header (default: 📋)
  7. Data model — what are the main things this app stores? Describe the entity name(s) and their fields briefly.

Confirm all values with the user before proceeding.

Step 2: Determine project directory

Check whether the current working directory is empty (contains no files or subdirectories, ignoring dotfiles like .git).

  • If the current directory is empty: use it as the project root. All files will be created here.
  • If the current directory is not empty: tell the user: "The current directory isn't empty. Please create and switch to a new empty directory for the project, then run /new-deno-app again." Stop here — do not proceed.

Step 3: Create project

Create all files in the project root determined in Step 2. All files below use the exact patterns from the reference app.

deno.json
json
{
  "imports": {
    "hono": "jsr:@hono/hono@^4",
    "hono/cookie": "jsr:@hono/hono@^4/cookie",
    "hono/deno": "jsr:@hono/hono@^4/deno",
    "@eta-dev/eta": "jsr:@eta-dev/eta@^3",
    "@std/assert": "jsr:@std/assert@^1"
  },
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-env --allow-read --unstable-kv main.ts",
    "start": "deno run --allow-net --allow-env --allow-read --unstable-kv main.ts",
    "test": "DENO_TLS_CA_STORE=system deno test --allow-env --unstable-kv",
    "fmt": "deno fmt",
    "lint": "deno lint",
    "check": "deno fmt --check && deno lint && deno check main.ts src/**/*.ts"
  },
  "fmt": {
    "lineWidth": 100,
    "semiColons": false,
    "singleQuote": false
  },
  "lint": {
    "rules": {
      "exclude": ["no-explicit-any"]
    }
  }
}
src/auth.ts

This is the exact auth pattern. Copy it verbatim — only the dev default password can be changed.

typescript
import type { Context, Next } from "hono"
import { getCookie, setCookie } from "hono/cookie"

async function hashPassword(password: string): Promise<string> {
  const data = new TextEncoder().encode(password)
  const buf = await crypto.subtle.digest("SHA-256", data)
  return Array.from(new Uint8Array(buf))
    .map((b) => b.toString(16).padStart(2, "0"))
    .join("")
}

export function getSessionToken(): Promise<string> {
  return hashPassword(Deno.env.get("APP_PASSWORD") ?? "changeme")
}

export function verifyPassword(submitted: string): boolean {
  const expected = Deno.env.get("APP_PASSWORD") ?? "changeme"
  return submitted === expected
}

export async function setSessionCookie(c: Context): Promise<void> {
  const token = await getSessionToken()
  const isProd = Deno.env.get("DENO_DEPLOYMENT_ID") !== undefined
  setCookie(c, "session", token, {
    httpOnly: true,
    sameSite: "Strict",
    secure: isProd,
    path: "/",
    maxAge: 60 * 60 * 24 * 30,
  })
}

export async function authMiddleware(c: Context, next: Next) {
  if (c.req.path === "/login") {
    return next()
  }

  const session = getCookie(c, "session")
  const expected = await getSessionToken()

  if (session !== expected) {
    if (c.req.header("HX-Request")) {
      c.header("HX-Redirect", "/login")
      return c.text("", 401)
    }
    return c.redirect("/login")
  }

  return next()
}
src/db.ts

Generate this based on the user's described data model. The KV singleton must store a Promise<Deno.Kv> (not the resolved instance) to prevent races when concurrent calls arrive before the first open resolves. Always export closeKv() for tests.

Template — replace Item / ["items", id] with the actual entities:

typescript
import type { Item } from "./types.ts"

let _kv: Promise<Deno.Kv> | null = null

function kv(): Promise<Deno.Kv> {
  if (!_kv) _kv = Deno.openKv()
  return _kv
}

export async function getItem(id: string): Promise<Item | null> {
  const db = await kv()
  return (await db.get<Item>(["items", id])).value
}

export async function listItems(): Promise<Item[]> {
  const db = await kv()
  const items: Item[] = []
  for await (const entry of db.list<Item>({ prefix: ["items"] })) {
    items.push(entry.value)
  }
  return items.sort((a, b) => a.name.localeCompare(b.name))
}

export async function saveItem(item: Item): Promise<void> {
  const db = await kv()
  await db.set(["items", item.id], item)
}

export async function deleteItem(id: string): Promise<void> {
  const db = await kv()
  await db.delete(["items", id])
}

export function closeKv(): void {
  _kv?.then((db) => db.close())
  _kv = null
}
src/types.ts

Define TypeScript interfaces based on the user's data model. Every entity must have:

  • id: string — use crypto.randomUUID() when creating
  • createdAt: string — ISO date string
src/views/eta.ts
typescript
import { Eta } from "@eta-dev/eta"

const isProd = Deno.env.get("DENO_DEPLOYMENT_ID") !== undefined
export const deploymentId = Deno.env.get("DENO_DEPLOY_BUILD_ID") ?? "dev"

// Resolve template directory relative to this file so it works on Deno Deploy
const templatesDir = new URL("../templates", import.meta.url).pathname

export const eta = new Eta({
  views: templatesDir,
  cache: isProd,
})
Show full SKILL.md (270 more words)Show less
src/templates/layout.eta

Fill in Display Name, emoji, short_name, and theme color. Keep all PWA meta tags.

html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title><%= it.title %> – <Display Name></title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.classless.min.css">
  <link rel="stylesheet" href="/static/styles.css">
  <link rel="manifest" href="/static/manifest.json">
  <link rel="apple-touch-icon" href="/static/apple-touch-icon.png">
  <link rel="icon" href="/static/favicon.ico">
  <meta name="theme-color" content="<theme-color>">
  <meta name="mobile-web-app-capable" content="yes">
  <meta name="apple-mobile-web-app-capable" content="yes">
  <meta name="apple-mobile-web-app-title" content="<Display Name>">
  <script src="https://cdn.jsdelivr.net/npm/htmx.org@2.0.4/dist/htmx.min.js"></script>
  <script src="/static/app.js" defer></script>
</head>
<body>
  <header>
    <nav>
      <a class="brand" href="/"><emoji> <Display Name></a>
    </nav>
  </header>
  <main>
    <%~ it.body %>
  </main>
  <footer>
    <small>Build: <%= it.deploymentId %></small>
  </footer>
</body>
</html>

If the app has multiple sections, add nav links inside <ul> in the <nav>. Use it.active to mark the current section with class="active".

src/templates/login.eta

Fill in emoji and Display Name.

html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title><Display Name></title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.classless.min.css">
  <link rel="stylesheet" href="/static/styles.css">
</head>
<body>
  <main>
    <div class="login-wrap">
      <h1><emoji></h1>
      <h2><Display Name></h2>
      <p>Enter the password to continue.</p>
      <form method="POST" action="/login">
        <input
          type="password"
          name="password"
          placeholder="Password"
          autocomplete="current-password"
          autofocus
          required>
        <button type="submit">Enter</button>
        <% if (it.error) { %>
          <p class="login-error">Incorrect password. Try again.</p>
        <% } %>
      </form>
    </div>
  </main>
</body>
</html>
src/templates/index.eta

Generate a sensible main page template for the app's primary entity. Use HTMX attributes (hx-get, hx-post, hx-delete, hx-target, hx-swap) for dynamic interactions. Keep it simple — a list view and a form to add new items.

static/manifest.json
json
{
  "name": "<Display Name>",
  "short_name": "<Short name>",
  "start_url": "/",
  "display": "standalone",
  "background_color": "<theme-color>",
  "theme_color": "<theme-color>",
  "icons": [
    { "src": "/static/icon-192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "/static/icon-512.png", "sizes": "512x512", "type": "image/png" }
  ]
}
static/sw.js
javascript
// Minimal service worker — required for PWA install prompt on Chrome/Android.
// No caching: all requests go to the network (app requires auth anyway).
self.addEventListener("fetch", (e) => e.respondWith(fetch(e.request)))
static/styles.css
css
.login-wrap {
  max-width: 360px;
  margin: 4rem auto;
  text-align: center;
}

.login-error {
  color: var(--pico-color-red-500);
}

Add any additional app-specific styles here. Keep it minimal — PicoCSS handles most things.

static/app.js
javascript
if ("serviceWorker" in navigator) {
  navigator.serviceWorker.register("/static/sw.js")
}

Add any additional client-side JS below the service worker registration.

main.ts

Wire up the Hono router. Follow this exact pattern for route organization:

typescript
import { Hono } from "hono"
import { setCookie } from "hono/cookie"
import { serveStatic } from "hono/deno"
import { authMiddleware, setSessionCookie, verifyPassword } from "./src/auth.ts"
import { deploymentId, eta } from "./src/views/eta.ts"
// import your db functions and view helpers here

const app = new Hono()

// ── Static files ───────────────────────────────────────────────────────────

app.use("/static/*", serveStatic({ root: "./" }))

// ── Auth ───────────────────────────────────────────────────────────────────

app.get("/login", async (c) => {
  const error = c.req.query("error")
  return c.html(await eta.renderAsync("login", { error: !!error }))
})

app.post("/login", async (c) => {
  const body = await c.req.formData()
  const password = body.get("password")?.toString() ?? ""
  if (!verifyPassword(password)) {
    return c.redirect("/login?error=1")
  }
  await setSessionCookie(c)
  return c.redirect("/")
})

app.get("/logout", (c) => c.redirect("/login"))

app.post("/logout", (c) => {
  setCookie(c, "session", "", { maxAge: 0, path: "/" })
  return c.redirect("/login")
})

// ── All other routes require auth ──────────────────────────────────────────

app.use("/*", authMiddleware)

app.get("/", async (c) => {
  // render main page
  const body = await eta.renderAsync("index", { /* data */ })
  return c.html(
    await eta.renderAsync("layout", { title: "Home", active: "home", body, deploymentId }),
  )
})

// add CRUD API routes for each entity here

// ── Start ──────────────────────────────────────────────────────────────────

Deno.serve(app.fetch)

For HTMX partial responses: check c.req.header("HX-Request") and return only the fragment HTML, not the full layout.

.gitignore
.env
*.db
CLAUDE.md

Generate a CLAUDE.md tailored to this app using this template:

markdown
# CLAUDE.md

## Commands

\`\`\`bash
deno task dev     # Start dev server with file watching
deno task test    # Run all tests
deno task fmt     # Format TypeScript files
deno task lint    # Lint TypeScript files
deno task check   # fmt check + lint + type check (run before committing)
\`\`\`

Formatting rules (from \`deno.json\`): 100-char line width, no semicolons, no single quotes enforced.
The \`no-explicit-any\` lint rule is disabled.

## Testing

Test files live alongside source files as \`src/*_test.ts\`. Run with \`deno task test\`.

**SSL certificates:** \`DENO_TLS_CA_STORE=system\` is set automatically by \`deno task test\` so Deno
uses the OS cert store for JSR imports.

**KV in tests:** \`src/db.ts\` exports \`closeKv()\` — call it in \`afterEach\` to release the KV
handle so Deno's leak sanitizer stays happy.

## Deployment

Pushing to \`main\` on GitHub automatically deploys to Deno Deploy.

## Architecture

**Stack:** Deno 2 + Hono + Deno KV + Eta + HTMX 2 + PicoCSS. No build step.

**Entry point:** \`main.ts\` — Hono router and all route handlers.

**Auth:** Single \`APP_PASSWORD\` env var. SHA-256 hash stored in session cookie. Dev default: \`changeme\`.

### KV Schema

\`\`\`
<describe the KV keys for each entity>
\`\`\`

Step 4: Create placeholder icon files

Create empty placeholder files for:

  • static/icon-192.png
  • static/icon-512.png
  • static/apple-touch-icon.png
  • static/favicon.ico

Tell the user: "You'll need to replace the placeholder icons in static/ with real ones before installing as a PWA."

Step 5: Initialize git and create GitHub repo

Run these commands in order:

bash
git init
git add .
git commit -m "Initial scaffold"
gh repo create <app-name> --private --source=. --remote=origin --push

Step 6: Final instructions

Tell the user:

  1. Run locally: deno task dev — opens on http://localhost:8000
  2. Dev password: changeme (set APP_PASSWORD env var for production)
  3. Deploy to Deno Deploy: Go to dash.deno.com → "New Project" → connect the GitHub repo <app-name>. Set the APP_PASSWORD env var in project settings.
  4. Replace icons in static/ with real PNG/ICO files at the correct sizes.
  5. Data model is in src/types.ts and src/db.ts — adjust as needed.

© jackfranklin, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in claude/skills/new-deno-app of jackfranklin/dotfiles.

Open the folder on GitHubat commit bfc6291

Compare with similar skills

New Deno App next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

New Deno App compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
New Deno App this skilljackfranklin/dotfiles255—~3.6kAutomated safety check: NotesMIT
Honodavila7/claude-code-templates33k3 repos~2.6kAutomated safety check: PassMIT
Olore Hono Latestolorehq/olore104—~1.1kAutomated safety check: PassMIT
Dddswamp-club/swamp646—~1.4kAutomated safety check: PassCustom licence
TS SDK Authormindfold-ai/Trellis15k—~6.1kAutomated safety check: PassMIT
Deno Scriptcataclysmbn/Cataclysm-BN1.3k—~1.8kAutomated safety check: PassCustom licence

Similar skills

  • Hono

    davila7/claude-code-templates

    Build ultra-fast web APIs and full-stack apps with Hono — runs on Cloudflare Workers, Deno, Bun, Node.js, and any WinterCG-compatible runtime.

    33k GitHub starsUsed in 3 repos~2.6k tokens
    Backend & APIsAuto-check passed

  • Olore Hono Latest

    olorehq/olore

    Local Hono documentation reference (latest). An agent skill from olorehq/olore.

    104 GitHub stars~1.1k tokensUpdated today
    Backend & APIsAuto-check passed

  • Ddd

    swamp-club/swamp

    Domain Driven Design guidance for TypeScript/Deno codebases.

    646 GitHub stars~1.4k tokensUpdated today
    DevelopmentAuto-check passed

  • TS SDK Author

    mindfold-ai/Trellis

    Design, build, verify, and publish production-grade TypeScript SDKs as npm packages inside a pnpm monorepo.

    15k GitHub stars~6.1k tokensUpdated 11 days ago
    DevelopmentAuto-check passed

  • Deno Script

    cataclysmbn/Cataclysm-BN

    Write or modify Cataclysm-BN Deno/TypeScript scripts. An agent skill from cataclysmbn/Cataclysm-BN.

    1.3k GitHub stars~1.8k tokensUpdated today
    DevelopmentAuto-check passed

  • Cloudflare Composition Root

    dmmulroy/skills

    Composition roots for Hono and Cloudflare. An agent skill from dmmulroy/skills.

    429 GitHub stars~2.1k tokensUpdated 2 mo ago
    DevelopmentAuto-check passed

More from jackfranklin/dotfiles

All 20 skills in this repo

  • GitHub Code Review

    jackfranklin/dotfiles

    Perform a thorough, read-only review of one GitHub pull request.

    255 GitHub stars~1.8k tokensUpdated today
    Auto-check passed

  • Adr

    jackfranklin/dotfiles

    Capture an Architecture Decision Record (ADR) for a significant decision made in the current project.

    255 GitHub stars~962 tokensUpdated today
    Auto-check passed

  • Jack References

    jackfranklin/dotfiles

    Manage Jack's personal technical reference library at ~/git/references.

    255 GitHub stars~1.2k tokensUpdated today
    Auto-check passed

  • Later

    jackfranklin/dotfiles

    Log items to come back to later — bugs found mid-task, feature ideas, project feedback — as GitHub Issues.

    255 GitHub stars~767 tokensUpdated today
    Auto-check passed

  • Resolve Merge Conflict

    jackfranklin/dotfiles

    A skill your agent uses when you need to resolve an in-progress git merge/rebase conflict.

    255 GitHub starsUsed in 23 repos~427 tokens
    Auto-check passed

  • Writing Great Skills

    jackfranklin/dotfiles

    Reference for writing and editing skills well — the vocabulary and principles that make a skill predictable.

    255 GitHub starsUsed in 15 repos~2.2k tokens
    Auto-check passed

Works with

Categories

Questions about New Deno App

What does New Deno App do?

Scaffold a new Deno 2 + Hono + Deno KV + Eta + HTMX app with password auth and PWA support. New Deno App is an agent skill from jackfranklin/dotfiles. Scaffold a new Deno 2 + Hono + Deno KV + Eta + HTMX app with password auth and PWA support.

When should I use New Deno App?

New Deno App fits situations like: the user wants to create a new personal web app following this stack.

How do I install New Deno App in Claude Code?

Run `npx skills add jackfranklin/dotfiles --skill new-deno-app -a claude-code`. Or copy the skill folder (claude/skills/new-deno-app in jackfranklin/dotfiles) into .claude/skills/new-deno-app in your project. Claude Code loads it when a task matches its description.

How do I install New Deno App in Codex?

Run `npx skills add jackfranklin/dotfiles --skill new-deno-app -a codex`. Or copy the skill folder (claude/skills/new-deno-app in jackfranklin/dotfiles) into .agents/skills/new-deno-app in your project. Codex loads it when a task matches its description.

Can I use New Deno App in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jackfranklin/dotfiles --skill new-deno-app -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/new-deno-app, .gemini/skills/new-deno-app, .github/skills/new-deno-app and .opencode/skills/new-deno-app in your project.

What does New Deno App need to run?

Going by SKILL.md and its folder, New Deno App needs the command-line tools its instructions call (git, gh and deno) and credentials named APP_PASSWORD.

Does New Deno App access the network?

SKILL.md names 1 domain. In commands or code: cdn.jsdelivr.net; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is New Deno App safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does New Deno App use?

New Deno App is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does New Deno App use?

About 3.6k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to New Deno App?

Skills that share tags, products or a category with New Deno App: Hono (davila7/claude-code-templates, 33k stars), Olore Hono Latest (olorehq/olore, 104 stars), Ddd (swamp-club/swamp, 646 stars) and TS SDK Author (mindfold-ai/Trellis, 15k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains New Deno App?

jackfranklin (a GitHub user) maintains it in jackfranklin/dotfiles, which has 255 GitHub stars. The repository holds 20 skills in this directory. The repository was last updated on October 10, 2026.

Source: jackfranklin/dotfiles on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.