Skip to content
Skills Library
Programming · Building & coding

greenfield-stack

/greenfield-stack

The house stack and the from-nothing build procedure — what to reach for when there is no existing project to match, and how to verify versions are current before writing. Use whenever starting something new ("build me a dashboard", "make a landing page", "new app", "from scratch", "scaffold"), or when picking a library for a greenfield feature.

Repository
smooth ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

The house stack and the from-nothing build procedure — what to reach for when there is no existing project to match, and how to verify versions are current before writing. Use whenever starting something new ("build me a dashboard", "make a landing page", "new app", "from scratch", "scaffold"), or when picking a library for a greenfield feature.

Triggers from the description

build me a dashboardmake a landing pagenew appfrom scratchscaffold
Original author description

The house stack and the from-nothing build procedure — what to reach for when there is no existing project to match, and how to verify versions are current before writing. Use whenever starting something new ("build me a dashboard", "make a landing page", "new app", "from scratch", "scaffold"), or when picking a library for a greenfield feature.

How it works

  1. The house stack
  2. Current-API traps
  3. Verify before you write
  4. The build order
  5. When the user names a different stack
  6. Related
Original SKILL.md headings · 105 lines, 708 words
SKILL.md preview
---
name: greenfield-stack
description: The house stack and the from-nothing build procedure — what to reach for when there is no existing project to match, and how to verify versions are current before writing. Use whenever starting something new ("build me a dashboard", "make a landing page", "new app", "from scratch", "scaffold"), or when picking a library for a greenfield feature.
---

# Building from nothing

Most guidance says "match the existing code". Greenfield has no existing
code — so that rule silently becomes "use whatever you remember", and
what you remember is your training data. That is the failure this skill
exists to prevent.

The two rules, in order:

1. **Do not invent a stack.** Use the house stack below.
2. **Do not trust the versions below, or your memory of the APIs.**
   Verify before writing (§ Verify).

## The house stack

Pinned to what `smooai/apps/web` actually ships, because "modern" means
"survives our codebase", not "recent".

| Need          | Use                                                   | Not                                                |
| ------------- | ----------------------------------------------------- | -------------------------------------------------- |
| App framework | **Next 16**, App Router, Server Components by default | `create-react-app`, Vite-for-an-app, pages router  |
| UI runtime    | **React 19**                                          | class components, `React.FC`                       |
| Styling       | **Tailwind 4**, CSS-first `@theme` tokens             | `tailwind.config.js`, CSS-in-JS, styled-components |
| Components    | **shadcn/ui** primitives (Radix under it)             | a component library nobody asked for               |
| Server state  | **TanStack Query v5**                                 | `useEffect` + `fetch` + three `useState`s          |
| Tables        | **TanStack Table v8**                                 | hand-rolled `<table>` with sort state              |
| Forms         | **react-hook-form** + zod resolver                    | uncontrolled `<form>` + manual validation          |
| Icons         | **lucide-react**                                      | an icon font                                       |
| Dates         | `Intl` / `date-fns`                                   | moment                                             |

**Server Components are the default.** Reach for `"use client"` only when
the component needs state, effects, or event handlers — and put it as low
in the tree as possible, not at the page root.

## Current-API traps

The idioms below are what a model trained a year or two ago produces.
They compile, they read fine, and they are wrong for this stack:

| Wrote                | Should be                                   |
| -------------------- | ------------------------------------------- |
| `tailwind.config.js` | `@theme { --color-brand: … }` in CSS        |
| `@tailwind base;`    | one `@import "tailwindcss";`                |
| `getServerSideProps` | a Server Component, or `fetch` in the route |
| `forwardRef(...)`    | `ref` as an ordinary prop (React 19)        |
| `useQuery(key, fn)`  | `useQuery({ queryKey, queryFn })`           |
| `cacheTime`          | `gcTime`                                    |
| `useTable(...)` (v7) | `useReactTable` + `getCoreRowModel()`       |
| `accessor:`          | `accessorKey` / `accessorFn`                |
| `useFormState`       | `useActionState`                            |

## Verify before you write

**This step is not optional, and it is the whole point of the skill.**
The table above has a date on it and the ecosystem does not care.

1. **Context7 MCP** — resolve the library, read the _current_ docs for
   the exact API you are about to use. Prefer this; it is live.
   Configure it once in `~/.smooth/mcp.toml`:

    ```toml
    [[servers]]
    name = "context7"
    command = "npx"
    args = ["-y", "@upstash/context7-mcp"]
    disabled = false
    ```

2. **No Context7 / no network?** Then read the source. Vendor the library
   into `.smooth/references/<lib>` and search it for the real API,
   examples and naming — the way opencode's `effect` skill does. Source
   beats memory; memory is the thing that is wrong.

3. **Still unsure of a version?** `npm view <pkg> version`. Never write a
   version number from memory into a `package.json`.

If you cannot verify, say so in your reply rather than guessing
confidently. A stated uncertainty is cheap; a confidently stale API costs
a debugging session.

## The build order

1. **Scaffold** with the framework's own tool (`npx create-next-app@latest`),
   not by hand-writing config files. It gets current defaults for free.
2. **Verify** the versions it produced are what you expected, and read
   what it generated before adding to it.
3. **Build the smallest working thing**, then iterate. A dashboard with
   one real table beats five stubbed panels.
4. **Handle loading and empty states** — the first render has no data.
   This is the most common gap in generated UI.
5. **Say what you chose and why** in one or two lines. A stack decision
   the user cannot see is one they cannot correct.

## When the user names a different stack

They win. Use what they asked for, and mention the house default once if
it is materially better for what they described — then drop it. Do not
relitigate.

## Related

- `docs/Engineering/Benchmarking-Modern-Stacks.md` — how we measure whether this works
- `crates/smooth-bench/greenfield-scenarios.toml` — the scenarios that score it

Versions

The database has no other skills named greenfield-stack.

Database snapshot: 13.11.2026 · package version e2807d9f88b7 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100tech-stack
    ☕️ cafe · The canonical, opinionated technology stack for any new project — what to reach for, in what order, and what to never touch. Use this whenever a new project starts or a stack decision comes up: scaffolding an app, prototype, dashboard, landing page, or design system,…
  • 90greenfield-architect
    Use when the user wants a new app, service, or system designed from scratch — greenfield work with no existing code to anchor to. Interactive architect: elicits requirements one question at a time, drives architecture proposals, recommends a stack with rationale, designs the API…
  • 100nextjs-stack
    This skill provides the default Next.js monorepo tech stack for rapid MVP development. Use when the user asks to "create a Next.js app", "add a new app to the monorepo", "build a dashboard", "scaffold a React page", "set up a new frontend", or when working in any project that…
  • 100stack-currency-check
    Verify that the patterns the model will use for a framework and version are current per official docs, and cache it as CURRENT_PATTERNS.md for the project. Use when impact-analysis flags greenfield work in an established framework, a new project uses newer-than-cutoff…
  • 90vibe-build
    Full end-to-end "vibe code" workflow for building software from scratch — research, bootstrap, plan, build, verify, ship — so the user never has to explain the process. Use when starting any new software project (app, website, game, tool, script, extension — any field), when the…
  • 91scaffold-app
    Scaffold a production-ready full-stack web app with auth (Passport.js local strategy), workspaces, profile, optional billing (Stripe), optional audit log, optional landing page. Vue 3 + Vite + Tailwind CSS 4 + shadcn-vue + Pinia frontend, Node.js + Express 5 + Passport + Knex +…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.