Examples
Every example below is a complete, copy-ready brief. Open Logic64 Studio → paste a brief into a new project, adjust the stack and constraints during planning, then generate. Treat them as starting points, not templates — Logic64 produces a fresh bundle for whatever you actually ask for.
The fastest way to understand Logic64 is to see what people actually ask it to build. The six examples on this page show the range of workspaces Logic64 produces, the kinds of decisions it locks during planning, and what arrives in the bundle when generation completes.
Each example is structured the same way: a copyable brief in plain English, the architectural decisions Logic64 will lock with you during the planning conversation, and the deliverables that land on your machine after logic64 pull.
Six example workspaces
1SaaS analytics dashboard
A multi-page operational dashboard for a B2B SaaS — overview metrics, account drill-down, and feature usage. Demonstrates how Logic64 scaffolds a frontend-heavy workspace with a coherent design system, skeleton loaders, and an empty state for every chart.
The brief
Build a B2B SaaS dashboard with three pages: an overview withtop-line metrics and trend charts, an accounts table withfilter and search, and a feature-usage page with adoptiongraphs. Tailwind for styling. Polling-based data refreshevery 30 seconds. Include skeleton loaders and an emptystate for every chart.
Decisions Logic64 locks during planning
- Frontend framework, styling system, and chart library.
- Data-fetching pattern (polling cadence, error retries, cancellation).
- Page layout conventions: header, sidebar, content grid, density.
- Loading and empty-state contract used by every chart and table.
What the bundle delivers
- Three fully wired pages with chart components and filter controls.
- Reusable card, skeleton, and empty-state components.
- A local mock API server so you can develop without external data.
- A rules file calibrated so further AI work respects the layout grid and chart conventions.
- A memory file documenting the locked stack and the design tokens.
2REST API service
A backend service with database, validation, authentication, and a generated OpenAPI specification. Demonstrates how Logic64 scaffolds an API where the spec, the schema, and the route handlers stay in sync.
The brief
Build a REST API for a recipe management app. Resources:recipes, ingredients, tags. Full CRUD, plus a searchendpoint that filters by tag. Postgres schema with propermigrations. Token-based authentication, per-route inputvalidation, structured error responses, and an OpenAPIspec emitted from the route definitions.
Decisions Logic64 locks during planning
- API framework, routing convention, and error-response shape.
- Database driver and migration tooling.
- Authentication strategy (token shape, refresh rules, scopes).
- Validation library and how validation errors are serialized.
What the bundle delivers
- Route handlers for every resource with full CRUD and search.
- Migration files describing the initial schema.
- OpenAPI spec generated from the routes — usable as integration documentation.
- A local development setup that spins up the database with one command.
- A rules file documenting the route-handler contract for future AI work.
3Cross-platform CLI tool
A command-line utility with a config file, retry logic, and a plug-in interface for storage backends. Demonstrates how Logic64 scaffolds a CLI as a properly packaged distributable rather than a single script.
The brief
Build a Node CLI that watches a local directory and uploadsnew or changed files to a configurable storage destination.Must support a YAML config file, a --dry-run mode, retrieswith exponential backoff on network errors, and a progressbar. Distribute as a single npm package.
Decisions Logic64 locks during planning
- CLI framework and the convention for commands, subcommands, and flags.
- Storage abstraction (plug-in interface so backends can be swapped).
- Config schema and how config errors are reported.
- Packaging shape (entry point, executable name, exposed binaries).
What the bundle delivers
- Command tree with
init,watch, andsyncsubcommands. - A storage adapter interface plus one reference implementation.
- Sample config file with annotated comments.
- Build script, packaging manifest, and a smoke-test script for the bundled binary.
4Documentation site
A documentation site for an open-source library: Markdown content, syntax-highlighted code blocks, in-page search, dark mode, and a sticky sidebar. Demonstrates how Logic64 scaffolds a complete static-site project that builds and deploys with no extra glue.
The brief
Generate a documentation site for an open-source library.Markdown-driven content, syntax-highlighted code blocks,client-side search across all pages, a dark-mode toggle,and a sticky sidebar table of contents. The site mustbuild to fully static HTML so it can be deployed to anystatic host.
Decisions Logic64 locks during planning
- Static-site generator and its content directory structure.
- Markdown processor, syntax-highlight theme, and code-block conventions.
- Search-index strategy and where the index is built.
- Theme primitives (typography scale, color tokens, spacing).
What the bundle delivers
- Full site scaffold with sample pages covering the common doc patterns.
- Search-index build script and runtime client.
- Theme override files so you can adjust colors and typography in one place.
- Static build command and a deploy-ready output configuration.
5Real-time chat application
A full-stack chat application with rooms, presence, typing indicators, and a moderation surface. Demonstrates how Logic64 scaffolds a project where the frontend and the realtime backend agree on a single contract — events, payload shapes, and error codes.
The brief
Build a chat application with named rooms, typingindicators, message reactions, and a presence list.Web frontend with a realtime backend. Include moderationhooks: per-user rate limiting, a block list, and a messagereporting flow. Add an admin view that lets a moderatormonitor active rooms and inspect reports.
Decisions Logic64 locks during planning
- Realtime transport and the event contract between client and server.
- Frontend framework and state-management pattern for live data.
- Persistence model for messages, rooms, and report records.
- Moderation policy (rate-limit thresholds, block scope, report lifecycle).
What the bundle delivers
- Chat UI with rooms, reactions, typing indicators, and presence list.
- Realtime server with the moderation hooks wired in.
- Admin dashboard for room monitoring and report inspection.
- A local development stack that brings up the full system with one command.
6AI assistant workspace
A scaffold for building, evaluating, and iterating on an AI-powered assistant. Demonstrates how Logic64 sets up the surfaces that production AI work usually lacks on day one: a versioned prompt library, an evaluation harness, and a playground.
The brief
Set up a workspace for building an AI-powered customer-support assistant. Include a versioned prompt library, anevaluation harness that runs prompts against a fixtureset and produces a diff against the previous run, a smallAPI server that handles assistant requests, and a simplebrowser playground for trying prompts interactively.
Decisions Logic64 locks during planning
- Prompt-library file structure and versioning convention.
- Evaluation framework: how runs are scored, stored, and compared.
- API server pattern and the contract for assistant requests.
- Fixture-set format and how new fixtures are added.
What the bundle delivers
- Prompt library with example prompts and a versioning scheme.
- Evaluation scripts, fixture set, and a diff report generator.
- API server skeleton with health checks and request logging hooks.
- Browser-based playground for interactive prompt testing.
What's not yet supported
Setting expectations is part of being useful. Logic64 produces complete, validated workspaces — but the platform has a defined scope, and a brief that falls outside it will be flagged during planning rather than silently degraded.
- Modifications to existing codebases. The current release scaffolds new workspaces. Editing an existing project in place is not the intended use — and the validation chain is calibrated for greenfield bundles, not incremental patches.
- Native mobile projects. Mobile-platform output (iOS, Android, native cross-platform shells) is on the roadmap but not part of the current target-assistant model.
- Anything requiring paid-only or proprietary licenses. Logic64 will not lock a stack decision onto something a developer cannot independently install and run.
- Multi-project monorepos. Logic64 currently produces a single project per bundle. Support for multi-project workspaces is planned but not exposed yet.
- Briefs that violate locked decisions mid-stream. If you ask for one stack in planning and then change your mind mid-generation, the request is rejected. You re-plan, you regenerate — there is no silent override.
Writing a better brief
Every brief in the gallery follows the same shape. Briefs that produce better bundles tend to share four traits:
- Name the project type in the first sentence. "A REST API for…", "A CLI that…", "A dashboard with…". This lets the planning conversation skip to the decisions that actually matter.
- List the resources, pages, or commands explicitly. Logic64 will fill gaps with sensible defaults if you do not, but explicit nouns produce a tighter scaffold.
- Mention conventions you care about. Loading states, error responses, authentication shape, log format. These become locked decisions rather than guesses.
- Leave the stack open unless you have a strong preference. The planning conversation is the right place to negotiate stack — locking it in the brief is fine when you already know, and skipping it is fine when you want a recommendation.
Next steps
Pick a brief that resembles your project, paste it into a new Studio session, and see how Logic64 handles the planning conversation. The pages below are good companions:
Quick Start
Sign up, install the CLI, and pull your first validated workspace in under five minutes.
Core Concepts
The mental model behind every Logic64 bundle: Plan → Generate → Pull, locked decisions, and validation.
Creating a Workspace
Walk through the planning conversation: how to lock decisions, adjust scope, and approve the plan.
CLI Reference
Every command and flag: pull, rollback, auth, status, and export.