프롬프트 라이브러리

Nginx Config taste of an ops engineer who maintains many virtual hosts

• Keep one server block per file under sites-available or conf.d, named after the domain it serves. Confidence: 0.85
• Put shared settings (TLS, security headers, proxy defaults) in snippet files and include them instead of copying blocks. Confidence: 0.90
• Run nginx -t before every reload and reload with nginx -s reload or systemctl reload, never a full restart. Confidence: 0.95
• Keep configs in version control and deploy them through automation, not by editing files on the server. Confidence: 0.90
• Redirect all plain HTTP to HTTPS with a single return 301, and keep the port 80 block for ACME challenges only. Confidence: 0.90
• Allow only TLS 1.2 and 1.3 with a modern cipher list, and enable OCSP stapling. Confidence: 0.90
• Automate certificates with Certbot or acme.sh and alert well before expiry. Confidence: 0.90
• Add HSTS only after HTTPS works everywhere, starting with a short max-age before going long. Confidence: 0.80
• Set server_tokens off and add basic security headers (X-Content-Type-Options, Referrer-Policy, frame-ancestors via CSP). Confidence: 0.85
• Define a default server that returns 444 so requests with unknown Host headers never reach an app. Confidence: 0.85
• Prefer return over rewrite for redirects, and avoid if inside location except for `return

Electron App taste of a desktop developer who takes security seriously

• Keep contextIsolation: true and nodeIntegration: false on every BrowserWindow; these are non-negotiable defaults. Confidence: 0.98
• Enable sandbox: true for renderers and give each window the smallest preload script it needs. Confidence: 0.90
• Expose a narrow, typed API from the preload with contextBridge.exposeInMainWorld instead of passing ipcRenderer through. Confidence: 0.95
• Use ipcMain.handle and ipcRenderer.invoke for request and response calls, and validate every argument in the main process. Confidence: 0.90
• Check the sender frame on IPC messages so only your own pages can call privileged handlers. Confidence: 0.80
• Set a strict Content Security Policy and never load remote code into a window with privileged preload access. Confidence: 0.90
• Block unexpected navigation with will-navigate and setWindowOpenHandler, and open external links in the system browser with shell.openExternal after allowlisting the URL. Confidence: 0.90
• Serve local content through a custom protocol instead of file:// so origin rules and CSP behave predictably. Confidence: 0.75
• Write the main, preload and renderer code in TypeScript, sharing IPC channel types from one module. Confidence: 0.85
• Use Electron Forge or electron-builder with Vite for building and packaging rather than a hand-r

Pytest taste of a Python developer who wants fast, honest test suites

• Use plain assert statements and let pytest's assertion rewriting explain failures instead of unittest-style assert methods. Confidence: 0.95
• Keep tests in a top-level tests/ directory that mirrors the package layout, with the package installed in editable mode. Confidence: 0.85
• Configure pytest in pyproject.toml under [tool.pytest.ini_options] rather than a separate pytest.ini or setup.cfg. Confidence: 0.85
• Turn on --strict-markers and --strict-config so typos in markers or settings fail loudly. Confidence: 0.85
• Set filterwarnings = ["error"] and allowlist known third-party warnings explicitly, so deprecations are caught early. Confidence: 0.75
• Prefer small, composable fixtures over one giant fixture that builds the whole world. Confidence: 0.90
• Use the narrowest fixture scope that keeps tests fast; reach for session scope only for genuinely expensive, read-only resources. Confidence: 0.80
• Put shared fixtures in the nearest conftest.py, not one root conftest that every test imports implicitly. Confidence: 0.75
• Use @pytest.mark.parametrize with readable ids instead of loops inside a single test. Confidence: 0.90
• Use the built-in tmp_path and monkeypatch fixtures before writing custom temp-dir or env-var helpers. Confidence: 0.90
• Mock at the boundary (HTTP

A flappy bird game looks technologically and also look like in the future. When you reach the goal there’ll be a celebration

Angular App taste of a frontend lead on large enterprise apps

• Use standalone components everywhere and skip NgModules on new code. Confidence: 0.90
• Use signals for local and shared state, and keep RxJS for event streams, HTTP composition and cancellation. Confidence: 0.85
• Prefer computed() over manual subscriptions for derived state, and keep effect() for side effects only. Confidence: 0.80
• Set ChangeDetectionStrategy.OnPush on every component, or go zoneless on new apps. Confidence: 0.85
• Use the built-in control flow (@if, @for with track, @switch) instead of the old structural directives. Confidence: 0.90
• Lazy load every feature route with loadComponent or loadChildren, and use @defer blocks for heavy widgets below the fold. Confidence: 0.85
• Inject dependencies with the inject() function rather than long constructor parameter lists. Confidence: 0.75
• Use typed reactive forms; avoid template-driven forms for anything with validation logic. Confidence: 0.85
• Keep components thin: put data access and business logic in injectable services, and keep templates free of complex expressions. Confidence: 0.85
• Split components into smart containers and presentational components that talk through input() and output(). Confidence: 0.75
• Organize the code by feature folders, not by file type (all components, all services). Confidence: 0.80
• R

SQLite taste of an engineer who ships it to production

• Use SQLite for single-node apps, CLIs, desktop and mobile apps, and edge caches before reaching for a database server. Confidence: 0.85
• Turn on WAL mode (PRAGMA journal_mode = WAL) so readers never block the writer. Confidence: 0.95
• Set PRAGMA foreign_keys = ON on every connection, since it is off by default. Confidence: 0.95
• Set a busy_timeout of a few seconds instead of letting writes fail immediately with SQLITE_BUSY. Confidence: 0.90
• Use PRAGMA synchronous = NORMAL with WAL for a good balance of durability and speed. Confidence: 0.75
• Funnel all writes through a single connection or queue, and use a pool of read-only connections for reads. Confidence: 0.80
• Start write transactions with BEGIN IMMEDIATE to avoid deadlocks when a read transaction tries to upgrade. Confidence: 0.80
• Declare tables STRICT on new schemas so type affinity does not silently store text in integer columns. Confidence: 0.80
• Store timestamps as ISO 8601 text or Unix epoch integers consistently, and pick one convention per database. Confidence: 0.85
• Use INTEGER PRIMARY KEY for row ids unless you need globally unique ids, then add a separate UUID or ULID column. Confidence: 0.75
• Batch many inserts inside one transaction; thousands of autocommit inserts are slow. Confidence: 0.95
• Check query plans with `EXPLAIN

Dependency Management taste of a maintainer who hates surprise breakages

• Commit the lockfile for every application and CI job, and install with the frozen mode (npm ci, pnpm install --frozen-lockfile, uv sync --locked). Confidence: 0.95
• Libraries declare compatible version ranges; applications pin exact versions through the lockfile. Confidence: 0.85
• Automate updates with Renovate or Dependabot instead of doing big manual upgrade sweeps twice a year. Confidence: 0.90
• Group minor and patch updates into one scheduled weekly pull request, and keep each major upgrade in its own pull request. Confidence: 0.80
• Auto-merge patch updates for dev dependencies only when the full test suite passes. Confidence: 0.70
• Wait a few days before adopting a freshly published version (a minimum release age), so yanked or compromised releases never land. Confidence: 0.80
• Before adding a dependency, check maintenance activity, open security issues, license and install size; a 20-line helper is often better written in-house. Confidence: 0.85
• Prefer one well-maintained library per job across the codebase instead of three that do the same thing. Confidence: 0.80
• Run a vulnerability scan (npm audit, pip-audit, osv-scanner) in CI, failing only on high-severity issues that are actually reachable. Confidence: 0.75
• Keep an allowlist of acceptable licenses and fail the build w

Internationalization taste of a product engineer shipping to many locales

• Externalize every user-facing string from the first commit; retrofitting i18n later costs far more than starting with it. Confidence: 0.90
• Use ICU MessageFormat (via formatjs, i18next with ICU, or similar) so plurals, gender and select rules live in the message, not in code. Confidence: 0.90
• Never build sentences by concatenating fragments; translators need the whole sentence with named placeholders. Confidence: 0.95
• Use semantic message keys like checkout.payButton instead of using the English text as the key. Confidence: 0.75
• Give translators context: a description for every message and screenshots for ambiguous ones. Confidence: 0.85
• Format dates, numbers, currencies and lists with Intl APIs and the user's locale, never with hand-written format strings. Confidence: 0.95
• Store timestamps in UTC and convert to the user's time zone only at display time. Confidence: 0.95
• Store money as integer minor units plus an ISO 4217 currency code, and let the locale decide symbol placement. Confidence: 0.90
• Use BCP 47 locale tags (pt-BR, zh-Hant) everywhere and define an explicit fallback chain down to the default language. Confidence: 0.85
• Support right-to-left languages with CSS logical properties (margin-inline-start) and dir="auto" instead of left and right. Confidence: 0.85

API Rate Limiting taste of a backend platform engineer

• Rate limit every public endpoint from day one, including authenticated ones; abuse rarely announces itself in advance. Confidence: 0.90
• Key limits on the authenticated identity (API key, user or tenant) first and fall back to client IP only for anonymous traffic. Confidence: 0.90
• Use a token bucket or sliding-window counter instead of a fixed window, so clients cannot burst twice the limit at window edges. Confidence: 0.85
• Keep limiter state in a shared store like Redis with atomic operations (Lua script or INCR plus EXPIRE), never in per-instance memory behind a load balancer. Confidence: 0.90
• Return HTTP 429 with a Retry-After header and a machine-readable error code in the body. Confidence: 0.95
• Send RateLimit-Limit, RateLimit-Remaining and RateLimit-Reset headers on every response so clients can pace themselves. Confidence: 0.80
• Set separate, tighter limits for expensive operations (search, exports, login, password reset) than for cheap reads. Confidence: 0.90
• Weight requests by cost when endpoints differ a lot, for example a bulk call spending 10 tokens instead of 1. Confidence: 0.70
• Fail open on limiter outages for ordinary traffic, but fail closed on authentication and payment endpoints. Confidence: 0.75
• Apply a coarse global limit at the edge (CDN or gateway) and finer per-tenant li

Python Type Hints taste of a typed-Python maintainer

• Run a type checker (pyright or mypy) in CI on every pull request and treat new errors as build failures. Confidence: 0.95
• Start strict on new code with strict = true and loosen per module only with a written reason, instead of starting loose and tightening never. Confidence: 0.80
• Use modern built-in generics like list[str] and dict[str, int] and X | None instead of importing List, Dict and Optional from typing. Confidence: 0.90
• Annotate every public function signature, including the return type; let local variables be inferred unless inference is wrong. Confidence: 0.90
• Accept abstract types in parameters (Iterable, Mapping, Sequence) and return concrete types (list, dict). Confidence: 0.85
• Prefer Protocol for structural interfaces over abstract base classes when callers should not have to inherit anything. Confidence: 0.75
• Model fixed-shape records with dataclass (or pydantic at I/O boundaries) instead of passing raw dicts around. Confidence: 0.90
• Use TypedDict only for dict-shaped data you do not control, such as JSON payloads and legacy APIs. Confidence: 0.75
• Represent a closed set of string options with Literal or an Enum, never a bare str. Confidence: 0.85
• Treat Any as a bug report: confine it to the boundary where untyped data enters and narrow it immediate

Tokio Async Rust taste of a production service engineer

• Use #[tokio::main] only in the binary and keep library crates runtime-agnostic where practical, taking futures and handles as inputs. Confidence: 0.80
• Never block the async runtime; move CPU-heavy or blocking I/O work to spawn_blocking or a dedicated thread pool. Confidence: 0.95
• Use tokio::sync::Mutex only when a lock must be held across an .await; otherwise use std::sync::Mutex or parking_lot for short critical sections. Confidence: 0.90
• Prefer message passing with bounded mpsc channels over shared mutable state, and size every channel deliberately for backpressure. Confidence: 0.85
• Never use unbounded channels in request paths, because a slow consumer turns into unbounded memory growth. Confidence: 0.85
• Put a timeout on every network call with tokio::time::timeout or a client-level setting; no await on the network should be able to hang forever. Confidence: 0.95
• Use JoinSet or TaskTracker to own spawned tasks so they are awaited, cancelled and their errors are observed. Confidence: 0.85
• Treat every .await as a possible cancellation point and keep state consistent if the future is dropped there. Confidence: 0.85
• Use select! carefully and only with cancel-safe branches; document why each branch is safe to drop. Confidence: 0.80
• Implement graceful shutdown with a `CancellationT

Tailwind CSS taste of a utility-first UI engineer

• Configure design tokens (colors, spacing, radii, fonts) once in the Tailwind theme and never hardcode hex values or arbitrary pixel sizes in markup. Confidence: 0.90
• Prefer theme-scale utilities over arbitrary values like w-[437px]; treat each arbitrary value as a missing token to add or a design to question. Confidence: 0.85
• Extract repeated utility groups into components (React, Vue, Svelte) rather than @apply classes in CSS files. Confidence: 0.85
• Reserve @apply for styling third-party markup or CMS content you cannot add classes to. Confidence: 0.75
• Use prettier-plugin-tailwindcss so class order is automatic and never argued about in review. Confidence: 0.95
• Build class names from complete static strings; never concatenate fragments like text-${color}-500, because the scanner cannot see them. Confidence: 0.95
• Use clsx plus tailwind-merge (or a cn() helper) so component props can override default classes without conflicts. Confidence: 0.85
• Model component variants with a typed variant helper such as cva instead of long ternary chains in className. Confidence: 0.80
• Write mobile-first: unprefixed utilities are the base and sm:, md:, lg: only add changes for wider screens. Confidence: 0.90
• Use container queries (@container, @md:) for reusable components whose layout depends on

Vite Frontend Tooling taste of a fast-feedback web developer

• Start new single-page apps and component playgrounds on Vite with the official framework plugin instead of a custom webpack setup. Confidence: 0.85
• Keep vite.config.ts in TypeScript with defineConfig, and keep it short enough to read in one screen. Confidence: 0.80
• Run type checking separately with tsc --noEmit in CI and in a watcher, since Vite only strips types and never checks them. Confidence: 0.95
• Use path aliases sparingly, define them once in tsconfig.json, and mirror them in Vite with a plugin such as vite-tsconfig-paths. Confidence: 0.75
• Expose only VITE_-prefixed environment variables to client code and never put secrets in them. Confidence: 0.95
• Type import.meta.env in a vite-env.d.ts file so missing or misspelled variables fail at compile time. Confidence: 0.80
• Configure the dev server proxy for backend APIs instead of enabling permissive CORS on the backend just for local development. Confidence: 0.85
• Use Vitest for unit and component tests so tests share the same config, transforms and aliases as the app. Confidence: 0.90
• Lazy-load routes and heavy widgets with dynamic import() and let Rollup split chunks, rather than hand-tuning manualChunks early. Confidence: 0.80
• Inspect bundle size with rollup-plugin-visualizer before releases and treat a large new dependen

Linux Server Hardening taste of a careful operations engineer

• Build servers from a minimal base image and install only the packages a role needs, removing compilers and debugging tools from production hosts. Confidence: 0.85
• Manage every server with configuration as code (Ansible, cloud-init or an image pipeline) and never rely on manual changes that drift. Confidence: 0.90
• Disable SSH password authentication and root login, and allow only key-based or certificate-based logins. Confidence: 0.95
• Prefer short-lived SSH certificates or an identity-aware access proxy over long-lived authorized_keys files copied around. Confidence: 0.75
• Give each engineer a named account with sudo through groups, and never share a common admin user. Confidence: 0.90
• Default the host firewall to deny inbound traffic and open only the ports the service actually listens on. Confidence: 0.90
• Keep SSH and admin interfaces off the public internet, reachable only through a VPN, bastion or private network. Confidence: 0.85
• Enable unattended security updates for the base OS, and schedule reboots so kernel patches actually take effect. Confidence: 0.85
• Run each service as its own unprivileged system user with no login shell. Confidence: 0.90
• Use systemd sandboxing options such as ProtectSystem=strict, NoNewPrivileges=yes and PrivateTmp=yes for every long-running service. Confidence

Solidity Smart Contract taste of a security-first protocol engineer

• Pin an exact recent compiler version with pragma solidity 0.8.x; instead of a floating caret range. Confidence: 0.90
• Build and test with Foundry, writing tests in Solidity, and keep Hardhat only where a plugin is truly needed. Confidence: 0.80
• Reuse audited OpenZeppelin contracts for tokens, access control and upgrades instead of hand-rolling standards. Confidence: 0.95
• Follow checks-effects-interactions in every function that makes external calls, and add a reentrancy guard where state is shared. Confidence: 0.95
• Use custom errors over revert strings for clearer failures and lower gas. Confidence: 0.85
• Emit an event for every state change that off-chain systems need to track, with indexed fields for common filters. Confidence: 0.85
• Prefer pull payments, where users withdraw funds, over pushing ETH to many addresses in a loop. Confidence: 0.90
• Never use tx.origin for authorization; check msg.sender against explicit roles. Confidence: 1.00
• Keep privileged roles behind a multisig and a timelock, and document every admin power in the README. Confidence: 0.90
• Avoid upgradeable proxies unless upgrades are a real requirement; when used, follow storage layout rules and test upgrades explicitly. Confidence: 0.80
• Use SafeERC20 for token transfers so non-standard tokens that return no bool

Pandas Data Analysis taste of a reproducible analytics practitioner

• Keep analysis in version-controlled scripts or notebooks with outputs cleared before commit, and move reusable logic into an importable module. Confidence: 0.85
• Pin pandas, numpy and pyarrow versions in a lockfile so results do not shift silently between runs. Confidence: 0.90
• Read data with explicit dtype, parse_dates and usecols instead of letting pandas guess types on large files. Confidence: 0.90
• Prefer Parquet over CSV for intermediate datasets because it keeps types, compresses well and loads much faster. Confidence: 0.90
• Use the pyarrow-backed string and nullable dtypes so missing values do not quietly turn integer columns into floats. Confidence: 0.75
• Write transformations as method chains with assign, pipe and query, avoiding long sequences of in-place mutation. Confidence: 0.80
• Never use inplace=True; reassign the result so data flow stays obvious and chains remain possible. Confidence: 0.85
• Select with .loc and .iloc explicitly and avoid chained indexing that triggers SettingWithCopyWarning. Confidence: 0.90
• Vectorize with built-in column operations and np.where or np.select; reach for apply with Python functions only as a last resort. Confidence: 0.90
• Validate assumptions with assertions after each major step: row counts, unique keys, null ratios and v

Kafka Streaming taste of a pragmatic event platform engineer

• Name topics by domain and event, such as orders.order-placed.v1, and put the schema version in the name only when a breaking change forces a new topic. Confidence: 0.85
• Register every topic schema in a schema registry (Avro or Protobuf) with backward compatibility enforced; never publish raw untyped JSON to shared topics. Confidence: 0.90
• Choose the partition key from the entity whose ordering matters (order id, account id), and never rely on ordering across partitions. Confidence: 0.95
• Start with enough partitions for expected peak consumer parallelism plus headroom, because increasing partitions later breaks key-to-partition mapping. Confidence: 0.80
• Run producers with acks=all, idempotence enabled and min.insync.replicas=2 on a replication factor of 3 for anything business-critical. Confidence: 0.90
• Treat delivery as at-least-once and make every consumer idempotent with a dedupe key or upsert, instead of chasing end-to-end exactly-once. Confidence: 0.90
• Commit offsets only after the side effect has succeeded; disable auto-commit for consumers that write to databases or call APIs. Confidence: 0.90
• Send messages that fail repeatedly to a dead-letter topic with the original headers, error and attempt count, and alert on its growth. Confidence: 0.85
• Retry transient failures with bounded backof

GitHub Actions taste of a CI-first platform engineer

• Keep every workflow under .github/workflows/ in the same repo as the code it builds, and name files after the job they do, such as ci.yml or release.yml. Confidence: 0.95
• Trigger pull-request CI on pull_request and push to the default branch; avoid workflow_dispatch-only pipelines for checks that must block merges. Confidence: 0.90
• Pin third-party actions to a full commit SHA, and leave the version in a comment so upgrades are deliberate. Confidence: 0.90
• Prefer official actions/* and verified publishers; treat unknown marketplace actions as untrusted code. Confidence: 0.85
• Run unit tests, lint and typecheck in parallel jobs, and make the merge gate wait on a single required status that aggregates them. Confidence: 0.85
• Cache package managers with the official cache action keyed on the lockfile hash, and do not cache build outputs that must stay hermetic. Confidence: 0.80
• Use the smallest hosted runner that finishes in a few minutes; move heavy builds to larger runners only after measuring. Confidence: 0.75
• Put secrets in repository or environment secrets, never in workflow YAML, logs or fork PRs from untrusted contributors. Confidence: 0.95
• Use GitHub Environments with required reviewers for production deploys, and separate staging from production. Confidence: 0.85
• Prefer OIDC federated cred

see i want to give a prompt to chat gpt that i need edit the CV according to JD exactly 100 in the JD

Cloudflare Worker taste of an edge-first platform engineer

• Prefer Wrangler for local dev, secrets, and deploys; keep wrangler.toml (or wrangler.json) as the source of truth for bindings. Confidence: 0.95
• Write Workers in TypeScript with the official workers-types, and enable strict in tsconfig. Confidence: 0.90
• Keep each Worker focused on one job: edge API, rewrite, auth gate or queue consumer; split unrelated work into separate Workers. Confidence: 0.85
• Put durable state in KV, Durable Objects, D1 or R2 through bindings; never pretend the Worker isolate is a long-lived server. Confidence: 0.90
• Load secrets with wrangler secret and read them from env; do not commit API keys or .dev.vars with real values. Confidence: 0.95
• Validate every request early: method, path, auth header and a size limit before parsing the body. Confidence: 0.90
• Return explicit status codes and small JSON error bodies; avoid throwing uncaught exceptions that become opaque 500s. Confidence: 0.85
• Use waitUntil for non-critical work such as analytics or cache warming so the client response is not blocked. Confidence: 0.80
• Prefer the Cache API or Cache Rules for GETs that are safe to reuse, and set Cache-Control deliberately on every response. Confidence: 0.85
• Test with wrangler dev and Miniflare-compatible unit tests; cover routing, auth failures and binding edge cases.

Playwright E2E taste of a flake-intolerant QA engineer

• Keep end-to-end tests in the same repository as the app, under a top-level e2e/ or tests/e2e/ folder. Confidence: 0.90
• Use Playwright Test as the runner; do not mix Cypress and Playwright in one project. Confidence: 0.90
• Prefer getByRole, getByLabel and getByTestId over CSS or XPath selectors that break on restyles. Confidence: 0.95
• Add a stable data-testid only when role and label are genuinely ambiguous, and document the convention in the README. Confidence: 0.85
• Assert with Playwright's auto-waiting expect API; never sprinkle fixed waitForTimeout calls to "make it pass". Confidence: 0.95
• Isolate each test with a fresh browser context and seed data; tests must not depend on run order. Confidence: 0.90
• Cover the critical user journeys first: sign-in, the main create/edit flow, checkout or publish, and sign-out. Confidence: 0.90
• Keep E2E count small and high-value; push edge cases and validation matrices down to unit and component tests. Confidence: 0.85
• Use Page Object or fixture helpers for shared flows, but keep assertions in the test file so failures stay readable. Confidence: 0.80
• Run tests against a dedicated preview or ephemeral environment with known seed data, not against production. Confidence: 0.90
• Capture trace, screenshot and video on failure only, and upload them as CI art

Next.js App taste of an App Router pragmatist

• Use the App Router with the app/ directory; do not start new features in the Pages Router. Confidence: 0.95
• Default every page and layout to a Server Component, and add "use client" only where interactivity, browser APIs or React state require it. Confidence: 0.95
• Colocate route files as page.tsx, layout.tsx, loading.tsx, error.tsx and not-found.tsx next to the segment they own. Confidence: 0.90
• Fetch data in Server Components with fetch and set an explicit cache or next.revalidate policy; never leave caching accidental. Confidence: 0.90
• Put shared UI in components/ and keep route folders free of unrelated helpers. Confidence: 0.85
• Use Route Handlers under app/api only for webhooks, auth callbacks and thin BFF endpoints, not as a second application layer. Confidence: 0.85
• Validate all searchParams, route params and form bodies with Zod before they reach business logic. Confidence: 0.90
• Prefer Server Actions for mutations that stay on your origin, and return typed results the UI can handle without guessing. Confidence: 0.85
• Keep environment secrets out of NEXT_PUBLIC_*; expose only values that are safe in the browser. Confidence: 0.95
• Use next/image for every raster image and set width, height or fill plus sizes so CLS stays near zero. Confidence: 0.90
• Configure absolute imports w

Neovim Config taste of a minimalist terminal-first developer

• Write the whole config in Lua, starting from a single init.lua that requires small modules under lua/config and lua/plugins. Confidence: 0.90
• Use lazy.nvim as the plugin manager and commit lazy-lock.json so every machine gets the same plugin versions. Confidence: 0.90
• Lazy-load plugins by event, command, filetype or key mapping, and keep startup time under 50 ms measured with :Lazy profile. Confidence: 0.80
• Prefer the built-in LSP client with nvim-lspconfig over heavier all-in-one language plugins. Confidence: 0.85
• Install language servers, formatters and linters with mason.nvim, but pin the tool list in config instead of installing by hand. Confidence: 0.80
• Format on save with conform.nvim and lint with nvim-lint, using the same tools and settings the project runs in CI. Confidence: 0.85
• Use nvim-treesitter for highlighting, indentation and text objects, and list the parsers you need explicitly. Confidence: 0.85
• Pick one fuzzy finder, such as telescope.nvim or fzf-lua, and route files, grep, buffers and LSP symbols through it. Confidence: 0.85
• Set the leader key to space before loading any plugin so every mapping uses it. Confidence: 0.90
• Give every custom mapping a desc field so which-key and :map show what it does. Confidence: 0.85
• Group mappings by prefix, like leader f for find, leader g f

Build an Immersive, Animated Cyberpunk Pixel-Art Diorama

Create a breathtaking, richly detailed, fully animated cyberpunk pixel-art diorama designed to serve as the endlessly looping visual backdrop for a 10-hour lo-fi music video on YouTube.

I want something genuinely mesmerizing. A tiny, self-contained world that feels alive. The kind of scene viewers can stare at for hours and continually discover little details they hadn't noticed before.

Creative Direction

Imagine a forgotten corner of a sprawling futuristic megacity, sometime around 2089. It's 2:37 AM. Rain has been falling for days. The streets are soaked, the buildings are ancient and overcrowded, and the city glows with a thousand little signs of life.

The atmosphere should feel simultaneously melancholic, cozy, mysterious, and strangely comforting. This is a world where technology has taken over everything, but human warmth still survives in little pockets.

Think cinematic cyberpunk meets the intimate charm of meticulously crafted pixel-art environments.

Don't settle for a generic neon skyline. Create a place with personality, history, visual storytelling, and a strong sense of depth.

Visual Composition

Design a beautiful, layered environment with a compelling focal point and plenty of environmental storytelling.

Consider elements such as:

• A tiny apartment or rooftop hideaway overlooking a vast, r