Markdowners

Rules for pairing YouTube titles and thumbnails as one packaging unit that drives clicks: complementary information, honest curiosity gaps, title length limits, and thumbnail composition for click-through rate.

Rules for writing YouTube video scripts that hold retention: the first 15 seconds, open loops, chapter structure, writing for the ear, retention edits, and CTA placement.

Preventing cross-site scripting and cross-site request forgery: context-aware output encoding, avoiding innerHTML with user data, CSP as defense in depth, strict sanitization allowlists, and SameSite cookies with CSRF tokens.

WordPress development conventions: child themes over core edits, hooks over patching, sanitize on input and escape on output, proper script/style enqueueing, universal prefixing, custom post types versus pages, and update discipline.

Rules for writing an automated welcome email sequence that earns future opens: sending the first email immediately, delivering the promised thing right away, one job per email, a deliver-story-value-ask arc, timing gaps between sends, and when to stop.

Rules for a weekly review that stays under an hour and actually resets the system: a fixed slot, emptying every inbox, honestly reviewing what slipped and why, planning next week's three outcomes, and reconciling calendar against tasks.

How to use web animation to communicate rather than decorate: duration bands for UI motion, easing choices, performant transform/opacity-only animation, prefers-reduced-motion support, avoiding layout-shifting motion, and entrance vs exit asymmetry.

Vue and Nuxt conventions: Composition API defaults, composables for shared logic, props-down-events-up data flow, computed over methods for derived data, single-file component structure, and Nuxt server routes and data fetching.

Rules for writing UX microcopy across buttons, labels, error messages, and empty states: verb-first buttons, error messages that state what to do next, no blame, no jargon, placeholder versus label use, and confirmation copy.

Writing unit tests that stay useful: testing behavior not implementation, one assertion focus per test, descriptive names as documentation, arrange-act-assert structure, fast and deterministic execution, disciplined mocking, and edge case coverage.

Rules for writing X (Twitter) threads that get read to the end: the payoff-promise opener, one idea per tweet, numbering conventions, standalone-quotable tweets, length bands, and closing CTAs.

Rules for planning a trip without chaos: anchor bookings first, one single plan document, realistic daily pacing, built-in buffer time, scenario-based packing lists, and offline copies of everything critical.

Rules for cleaning up raw transcripts into readable text: verbatim versus clean-read decisions, filler removal, speaker labels, punctuation for spoken rhythm, and inaudible/crosstalk conventions.

Rules for sending transactional email correctly: separation from marketing streams, immediate delivery, fact-based subject lines, self-contained body content, SPF/DKIM/DMARC deliverability basics, and plain-text fallback.

Rules for defining and applying a consistent brand voice: naming voice traits with do/don't pairs, calibrating formality, keeping consistency across channels, distinguishing voice from tone, and maintaining a banned-phrases list.

Rules for making TikTok and Reels videos that hold attention: the first-second hook, native-feel pacing, pattern interrupts, text overlays, trend use, loopability, and caption discipline.

Rules for writing docs, READMEs, and guides that developers actually use: audience-first framing, one idea per sentence, examples over abstraction, structure, terminology consistency, and what to cut.

Rules for running a task list that actually gets done: next-action phrasing, capture-then-triage, one honest daily priority, real due dates only, weekly cleanup, and list hygiene.

Rules for building study plans that actually prepare someone for an exam: backward planning from the exam date, spacing and interleaving, active recall over rereading, realistic session sizing, weak-topic prioritization, and review cadence.

Rules for narrative structure in any written piece: stakes before detail, concrete specifics over abstraction, one protagonist, conflict as the engine, show-then-tell, and how to find the story in dry material like case studies and data.

Rules for writing speeches meant to be heard, not read: short spoken-length sentences, the rule of three, callbacks, opening strong and closing stronger, rhythm and pause marks, and the read-aloud test.

Rules for writing song lyrics that sing well and land emotionally: concrete imagery over abstraction, hook repetition, verse/chorus/bridge structure, natural rhyme, and prosody against the beat.

Rules for writing a social media profile bio that converts a visit into a follow: the who/what/why-follow line, keyword placement for in-app search, CTA and link strategy, platform character limits, and what to cut.

Rules for sending SMS notifications correctly: reserving SMS for urgent/actionable messages, explicit opt-in with easy STOP, sender identification, the 160-character discipline, quiet hours, trustworthy link shortening, and cost awareness.

Write serverless and edge functions that perform well and cost predictably: stateless handlers, cold-start budgets, timeout and memory sizing, idempotency for retries, database connection pooling, local dev parity, and cost awareness.

Rules for writing blog posts that rank and read well: search-intent match, one primary keyword with natural variants, title and H2 structure, scannability, internal linking, meta descriptions, and refreshing old posts.

Rules for writing and rewriting a resume that passes ATS screening and reads well to a human: one-page defaults, metric-driven achievement bullets, tailoring to a job description, and what to cut.

Design consistent, predictable REST APIs: resource-oriented URL paths, correct status codes, a uniform error envelope, pagination/filtering/sorting conventions, versioning, and idempotency.

Rules for writing recipes that are actually cookable under pressure: ingredients in use-order with prep noted, exact quantities and units, one action per step, explicit time and temperature, substitutions, yield, and storage.

Component and hook conventions for React apps: composition over inheritance, honest dependency arrays, state colocation, derived state, controlled forms, key discipline, and measured memoization.

Rules for building retrieval-augmented generation systems that actually retrieve the right thing: chunking strategy, metadata filtering, hybrid search, retrieval evaluation, citation, and re-indexing discipline.

Django project conventions: fat models thin views, queryset optimization with select_related and prefetch_related, migrations discipline, forms/serializers for validation, per-environment settings, and app boundaries.

Rules for writing business proposals that win work: opening with the client's problem in their own words, scope with explicit exclusions, options with a clear recommendation, pricing presentation, and a strong next-step close.

Rules for building reusable LLM prompt templates: variable delimiting, system/user separation, input escaping, versioning, few-shot examples as data, edge-case testing, and output format contracts.

How to write prompts that reliably produce the output you want: specific over vague instructions, examples over descriptions, positively stated constraints, stable-first context ordering, explicit output format, iteration over mega-prompts, and testing prompts like code.

Rules for professional emails that get read and acted on: subject lines that state the ask, one topic per email, front-loaded requests, formatting for skimming, and reply/CC/forward discipline.

Rules for ecommerce product description copywriting that converts: outcome-first leads, keyword placement, feature-benefit pairing, sensory language, and objection handling.

Rules for writing press releases journalists actually use: the inverted pyramid, leading with the newsworthy angle, headline and subhead construction, quotes that sound human, boilerplate structure, and what journalists skim for.

Rules for writing product requirements documents that engineering can actually build from: problem before solution, user stories with acceptance criteria, non-goals, success metrics, and open questions.

Rules for writing podcast show notes and episode descriptions that convert browsers into listeners: hook paragraphs, timestamped chapters, guest bios, pull quotes, and SEO-aware titles.

Rules for writing startup pitch decks that hold investor attention: the 10-slide skeleton, headline-as-takeaway titles, numbers with context, design restraint, and audience tailoring.

Rules for writing AI image prompts that produce convincing photographic results: camera and lens language, lighting vocabulary, composition terms, realism anchors, and avoiding the tells that make AI photos look fake.

Rules for a personal budget that survives real spending: track before optimizing, set category budgets from actual history, automate pay-yourself-first savings, split fixed from variable costs, run a monthly review, build a buffer, and skip shame accounting.

Rules for writing performance reviews that are fair and useful: evidence-based specifics, behavior over personality framing, the SBI structure, balanced but honest assessment, forward-looking goals, and the no-surprises rule.

Use an ORM (Prisma or equivalent) without its convenience becoming a performance or security liability: N+1 detection and eager loading, transactions for multi-write invariants, parameterized queries only, selecting only needed columns, ORM-managed migrations, and when to drop to raw SQL.

Rules for writing OKRs that actually drive outcomes: outcomes over tasks, measurable key results, a 3-5 key-result cap, ambition calibration, scoring discipline, and common anti-patterns like sandbagging and task-list key results.

Rules for taking notes that are actually usable later: own-words capture over transcription, atomic notes with links, separating capture from organizing, progressive summarization, retrieval-friendly titles, and a review loop that actually happens.

Model document databases like MongoDB correctly: design for access patterns rather than normalization, choose embed vs. reference deliberately, denormalize with an explicit update plan, avoid unbounded arrays, index for real queries, and validate schema even in a schemaless store.

Express API conventions: router/controller/service layering, centralized error middleware, async handler wrapping, edge validation, env-based config, graceful shutdown, and keeping routes free of business logic.

Rules for writing email newsletters that get opened and read: subject line discipline, preview text, one job per email, scannable structure, send rhythm, and what makes people archive on sight.

Monorepo conventions for multi-package repositories: explicit package boundaries and dependencies, shared config packages, avoiding circular dependencies, affected-only CI, versioning strategy, and when a monorepo is the wrong answer.

Rules for meal planning that survives a real week: plan around the actual calendar not an ideal one, use a repeatable rotation with one new dish, group the grocery list by store section, batch-cook overlaps, and treat leftovers as planned meals.

Rules for writing a logo design brief that produces usable concepts: brand attributes before visuals, audience and usage contexts, required sizes, color and monochrome requirements, references, and feedback vocabulary.

Rules for building genuinely localizable products: externalized strings, no string concatenation, ICU pluralization, locale-aware date/number/currency formatting, text expansion room, RTL awareness, meaning-first translation, and translator context.

How to integrate an LLM API into a production application: never trust model output blindly, streaming UX, retry with backoff on rate limits, token budget management, PII-aware prompt/response logging, fallback behavior on failure, cost monitoring, and model version pinning.

Rules for writing a literature review that synthesizes rather than summarizes: thematic organization instead of paper-by-paper summaries, contradiction mapping, gap identification, source quality tiers, and scope discipline.

Rules for optimizing a LinkedIn profile as a standing asset, distinct from post writing: the headline formula beyond job title, an About section written as narrative, keyword placement for recruiter search, the Featured section, and experience bullets.

Rules for structuring language learning around what actually builds fluency: comprehensible input volume, speaking early despite errors, frequency-first vocabulary, sentences over isolated words, spaced review, tolerating ambiguity, and handling plateaus.

Rules for writing landing page copy that converts: one page one goal, a headline that states the value promise, hero-to-proof-to-objections-to-CTA hierarchy, specificity over adjectives, social proof placement, and CTA wording.

Rules for keyword research that maps to a real content strategy: search intent classification, long-tail versus head terms, difficulty-versus-relevance tradeoffs, clustering into topics, mapping keywords to pages, and avoiding cannibalization.

Rules for journaling prompts that produce real reflection instead of a blank page: specific over generic, morning vs evening formats, concrete gratitude, decision journaling, rereading cadence, and keeping the habit alive.

Rules for writing job descriptions that attract the right candidates: real responsibilities over buzzwords, must-have versus nice-to-have separation, salary transparency, inclusive language, and cutting requirement inflation.

Rules for writing Instagram and TikTok captions that get read and acted on: the hook before the fold, length by post type, hashtag strategy, CTAs, voice, and adapting one caption across platforms.

Validating untrusted input at every trust boundary: server-side enforcement, allowlists over blocklists, schema and range checks, canonicalization, and safe error messages.

Rules for writing headlines and titles across formats: specificity over vagueness, curiosity paired with a real payoff, using numbers and brackets effectively, length bands per channel, banned clickbait patterns, and testing variants.

Rules for building habits that actually stick: start absurdly small, anchor to an existing routine, track streaks without perfectionism, design the environment for the behavior, use identity framing, and build one habit at a time.

Design GraphQL APIs that scale: schema-first modeling, deliberate nullability, connection-style pagination, DataLoader batching, structured errors, and query depth/complexity limits.

Rules for building and maintaining a terminology glossary for translation or domain-specific writing: one canonical term per concept, a consistent entry format (term, definition, context, forbidden synonyms), source-of-truth maintenance, domain scoping, and when to add versus prune entries.

Git workflow rules for teams: small atomic commits with imperative messages, branch naming, rebase versus merge policy, pull request size caps, never force-pushing shared branches, why-focused commit bodies, and .gitignore hygiene.

Building privacy-compliant apps: data minimization, lawful basis before collection, real and revocable consent, retention limits with actual deletion, subject access/export/delete rights, and accurate privacy policies.

Build full-text search that returns relevant results: analyzer and tokenizer choices, balancing exact vs. fuzzy matching, relevance tuning with field boosts, result pagination, keeping the search index in sync with the source of truth, highlighting, and zero-result handling.

Rules for writing spaced-repetition flashcards that actually build recall: the minimum information principle, active-recall phrasing, cloze deletion, and deck structure for Anki-style study.

Handling user file uploads safely: validating type by content not extension, enforcing size limits, re-encoding images, storing outside the webroot, random filenames, never executing from upload dirs, malware scanning, and correct serving headers.

Rules for writing executive summaries that stand alone: decision-oriented content, strict length caps, what belongs versus what doesn't, and why the summary should always be written last.

Rules for the final stretch of exam preparation: past-paper practice under timed conditions, error logs, topic triage by marks-per-effort, the last-week taper, day-of routine, and what cramming can and cannot do.

Rules for writing academic essays with a clear argument: the thesis as one arguable sentence, paragraph structure of claim plus evidence plus analysis, counterargument handling, intro and conclusion discipline, signposting, and separating the editing pass from drafting.

How to build HTML emails that actually render across clients: table-based layout, inline CSS, the 600px width convention, alt text and image fallbacks, dark mode quirks, plain-text versions, and cross-client testing.

Rules for editing and proofreading any draft: a structure-to-clarity-to-line-to-proof pass order, cutting 10-20% of length, catching passive voice and filler words, consistency checks, and preserving the author's voice.

Writing end-to-end tests that stay reliable and fast: covering critical user journeys not everything, resilient role/test-id selectors, waiting on conditions instead of sleeping, test data isolation, treating flakiness as a bug, and keeping the suite runnable.

How to build and maintain a design system that scales: design tokens before components, consistent component APIs, composition over configuration, live documentation, versioning and deprecation, and contribution discipline.

How to design dashboards and data tables that communicate clearly: visual hierarchy for the most important number, progressive disclosure from overview to drill-down, table conventions (alignment, sorting, sticky headers, pagination), honest chart types, and empty/loading/error states.

Rules for writing a cover letter that earns its place: 250-350 word limit, a company-specific hook, evidence over restatement, a direct close, and honest handling of gaps or career changes.

Rules for building a content calendar that survives contact with reality: content pillars before individual posts, sustainable cadence, batching, a repurposing matrix, timely-vs-evergreen slotting, and a review loop.

Rules for managing a brand's social community day to day: response time and tone, handling public criticism, when to move a conversation to DM, moderation lines, rewarding contributors, and never arguing with trolls.

Rules for building a UI color palette that works in practice: the 60-30-10 distribution, a single accent job, reserved semantic colors, WCAG text contrast ratios, light/dark variants, and naming tokens by role.

Rules for writing B2B cold outreach emails that get replies instead of being marked as spam: earning the send, subject lines that read as internal, under-120-word structure, real personalization, and follow-up cadence.

Running code review that actually improves code: correctness before style, small diffs for better review quality, severity-labeled comments, asking instead of commanding, responding to every comment, clear approval criteria, and automating what linters can catch.

Documentation rules for codebases: a README that answers install, run, and deploy in minutes, comments that explain why never what, docs colocated with code, examples that actually run, deleting stale docs, and ADRs for decisions.

Rules for formatting citations correctly and consistently: choosing one style (APA, MLA, or Chicago) and sticking to it, in-text versus bibliography formatting, citing only sources actually read, quote-versus-paraphrase discipline, plagiarism-safe practice, and reference manager hygiene.

Building CI/CD pipelines that catch problems early and deploy safely: fast feedback ordering, fail fast, dependency caching, secrets via the platform's store, deploying from main only, a rollback plan, and no manual production steps.

Rules for ecommerce checkout flows that convert: mandatory guest checkout, form field minimalism, upfront cost visibility, progress indication, payment method breadth, error recovery, and trust signal placement.

Apply a disciplined caching strategy: cache-aside as the default pattern, TTLs on everything, explicit invalidation on writes, stampede protection, versioned cache keys, what to never cache, and measuring hit rates.

Rules for writing business reports that get acted on: conclusion-first BLUF structure, data presented with context, one chart per message, clear recommendation sections, and appendix discipline.

Rules for building a brand style guide that actually gets used: logo usage constraints, exact color codes with usage ratios, typography hierarchy, a short voice summary, do/don't examples, and length discipline.

Build reliable background job and queue systems: idempotent handlers, retry with backoff and dead-letter queues, small payloads, timeouts, at-least-once delivery, queue-depth monitoring, and graceful worker shutdown.

Rules for writing API reference documentation developers can actually use: runnable examples per endpoint, realistic request/response pairs, a full error catalog, auth explained first, breaking-change changelogs, a five-minute quickstart, and generating docs from source of truth.

Guardrails for an autonomous AI agent with real permissions: confirm destructive actions, never print or commit secrets, strict scope discipline, flag external side effects before executing, state uncertainty honestly, never fabricate source-of-truth content.

How an AI coding assistant should match a codebase rather than impose its own preferences: mirror existing style, avoid drive-by refactors, keep diffs minimal, comment only where code can't speak, never leave placeholder code, respect the project's stack choices, and ask before adding dependencies.

Rules for writing paid ad copy that converts across Facebook, Google, and other placements: one promise per ad, benefit before feature, message match to the landing page, compliance basics, and single-variable testing.

Rules for abandoned cart recovery email sequences: send timing, showing actual cart contents, single-CTA restoration, incentive escalation discipline, objection handling, stop rules, and non-creepy subject lines.

How to receive any provider's webhooks safely: signature verification, idempotent processing, fast acknowledgment, and ordering assumptions.

Rules for producing translations that are faithful and natural at once: register, glossary discipline, false friends, locale formatting, and what to leave untranslated.

A pragmatic testing pyramid and CI discipline focused on tests that actually catch real regressions, not coverage-number theater.

Stripe-specific integration rules on top of payment-system-basics: key handling, Elements, SCA/3DS, and treating webhooks as the source of truth.

Keeping an established session safe for its whole lifetime: cookie flags, revocation, CSRF defenses, and concurrent-session visibility.

The baseline technical and content rules that make pages crawlable, indexable, and worth ranking, before any advanced SEO tactic.

Mobile-first layout rules for interfaces that hold up from a 360px phone to a 1920px desktop without horizontal scroll or broken touch targets.

Which endpoints need explicit abuse budgets, how to choose limits per identity axis, and how to respond to breaches without leaking exploitable detail.

The extra bar template-generated pages must clear: genuine per-page uniqueness, real underlying data, and crawl-budget-aware scale.

PostgreSQL-specific conventions on top of database-design-basics: naming, precise types (citext/jsonb/timestamptz), and RLS basics.

PHP + MySQL conventions on top of database-design-basics: prepared statements, utf8mb4, InnoDB, and PHP's shared-nothing request lifecycle.

PayPal-specific order/capture rules on top of payment-system-basics: server-side capture verification, idempotency, and sandbox testing.

Foundational rules for handling money safely: server-side pricing authority, idempotent charges, integer currency math, and staying out of PCI scope.

The OAuth/social-login handshake done correctly: PKCE, state validation, safe token handling, and account-linking without takeover risk.

App Router conventions: server-vs-client component defaults, safe env-variable exposure, and where data fetching and mutations belong.

How to change a live schema safely: backward-compatible rollout steps, no same-migration drops, and lock-aware changes on large tables.

The exact meta, Open Graph, and Twitter Card tags every public page needs, and how to generate them correctly for dynamic pages.

A capture format for meeting notes that separates decisions from actions from open questions, so notes are usable minutes rather than a transcript nobody rereads.

Rules for writing LinkedIn posts that actually get read: the first-two-lines hook, length bands, formatting, hashtag discipline, CTAs, and repurposing long content.

How to structure image-generation prompts that produce consistent, controllable results: subject/style/composition/lighting, negative prompts, iteration, and an ethics note on artist names.

How to validate forms so errors are clear, input is never lost, and client-side checks never substitute for real server-side validation.

How to fail loudly in development, gracefully in production, and always leave a diagnosable trail instead of a silent or generic failure.

Rules for keeping credentials out of git, out of client bundles, and rotatable — so a leak is an inconvenience, not a breach.

Rules for turning a transcript or video into broadcast-quality English subtitles: SRT/VTT formatting, line length, reading speed, timing, and punctuation conventions.

The email+password login flow specifics built on auth-fundamentals: signup verification, login timing safety, and password-change session rules.

Rules for summarizing a document or multiple sources faithfully: length targets, fidelity to the source, structure, and exact preservation of numbers and quotes.

Schema fundamentals that prevent the expensive-to-fix mistakes: keys, constraints, normalization, correct types, and indexing discipline.

Core authentication rules every login system needs: password hashing, session revocation, verification, and the line between authentication and authorization.

How an AI coding agent should behave in a real codebase: ask before destructive actions, stay in scope, never fabricate, and know when to stop.

Baseline accessibility rules — semantic HTML, keyboard operability, contrast, and screen-reader support — built in from the first component.

E-commerce checkout context

The rules an AI agent needs to build a safe, accessible checkout flow: payments, Stripe, webhooks, form UX, error handling, sessions, and accessibility.

SaaS starter context

Everything a new SaaS codebase needs on day one: project conventions, auth, database, testing, error handling, secrets, and SEO basics.