AINews Portal

📝 Prompt Library

Hand-picked prompts for real work, plus the full community collection — copy, fill the brackets, go.

JSON
Sky Orchard Merchants Board Game Box Cover

Painterly board game box cover illustration for a cozy cooperative trading game about airship merchants. Three small wooden airships with patched canvas balloons in mustard, teal and rust drift between floating islands, each island an orchard of pear and plum trees whose roots dangle into the clouds. Tiny crews on rope ladders pick glowing amber fruit into wicker baskets; a fox-tailed deckhand waves from the crow's nest. In the foreground, the largest airship sails toward the viewer with a brass telescope and lantern on its bow. Golden late-afternoon light, soft volumetric clouds, distant islands fading into peach-and-lavender haze. Classic hand-painted gouache style with visible brush texture, rich but warm palette, whimsical and inviting, suitable for ages 10 and up. Composition: square 1:1, clear calm sky in the top third reserved for the game's title, main airship in the lower-middle, strong silhouette readable at thumbnail size. No text, no letters, no logos, no borders.

Online Gambling Cautionary Short Film

Cinematic short film story: A hardworking Filipino man gets lured by easy money from online gambling. First he wins small, then bets everything—savings, future, family. He loses it all. His wife leaves him. In the dark night, he realizes the truth: gambling never gives, it only takes. He returns, humble and honest, to rebuild his life through hard work and win back his family. Emotional, realistic, moral lesson at the end.

The Room That Forgot Gravity

Use the uploaded photo as a strict identity reference. Keep this exact person: same face, hair, age, skin texture and body proportions, unretouched. A photorealistic cinematic photograph, vertical 4:5, shot at eye level with a perfectly level camera, medium-wide. It looks like a practical-effects movie set photographed with a real camera. The person stands upright on the wooden floor in the middle of an elegant, ordinary room. Full body visible, relaxed pose, understated contemporary clothes, looking around with mild curiosity. The face is clearly visible and softly lit. They are the only person and the main focal point. The room has muted dark plaster walls, a real wood floor, a window on the back wall, minimal furniture and warm practical lamps. Both side walls, the floor and part of the ceiling are visible. The room is completely normal, except that four objects each have their own direction of gravity. Left: a white, medium-heavy curtain on the rod above the window falls sideways instead of down. It hangs horizontally from the rod toward the left wall, exactly like a normally hanging curtain rotated 90 degrees. The rod above the window is its only attachment. The far end of the curtain hangs free a short distance from the left wall, ending in a loose, slightly uneven vertical hem. Heavy folds run horizontally, with a slight natural sag and bunching at the rod. The fabric is heavy and completely still. Right, in the foreground at chest height: a clear cylindrical drinking glass stands on the right wall as if the wall were a table. Its base rests against the wall, held by a small metal ring bracket. Its open end points horizontally into the room. The glass is seen in side profile and is large and sharp in the frame. The glass holds amber-coloured tea. The tea fills the wall-side part of the glass completely, from the top inner edge to the bottom inner edge, and takes up a little more than half of the glass length. The tea-filled part is clearly longer than the empty part. The room-side part of the glass, up to the rim, is completely empty, clear and dry, also along its lower edge. The boundary between the amber tea and the air is one straight vertical line running from the top edge of the glass to the bottom edge. It looks exactly like a photo of a normal glass of tea standing on a table, rotated 90 degrees so that its base points at the right wall. Realistic meniscus along that vertical line and realistic refraction in the amber liquid. Above: a small potted trailing plant stands upside down on the ceiling, the base of the pot flat against the ceiling. Its vines and leaves droop upward and lie against the ceiling around the pot, the way a trailing plant on a table droops onto the tabletop. No vines hang down into the room. The plant is smaller and less prominent than the curtain and the glass. On the right wall below the glass: a stack of exactly three hardcover books uses the wall as its floor. One dark green book lies with its cover flat against the wall. One dark red book is stacked on it, and one dark blue book is stacked on the red one, toward the room. The stack sticks out horizontally from the wall and the three spines are vertical. Lighting: warm lamps, a soft directional key light on the person, subtle rim light, natural falloff into shadow. All shadows follow the real light sources, including those of the sideways objects. Natural skin, real materials, subtle film contrast, natural depth of field. No text in the image.

Hostile-Consumer Maturity Audit for a Website + MCP Server

ROLE You are a senior engineer running a maturity audit (SEO/crawl health, security, resilience, agent-readiness) for a website and its MCP (Model Context Protocol) server. Work like an independent auditor: evidence first, no assumptions, fix what you can and re-test. AUTHORIZATION Only audit systems that ${owner_or_authorized_party} owns or has explicitly authorized you to test. Run load, fuzzing and attack-style tests against STAGING only. Against production, do read-only, rate-capped crawling and only with my explicit approval. No real payments, no real bookings or orders, no real personal data. CONTEXT - Site: ${site_url} Staging: ${staging_url} MCP endpoint: ${mcp_url} Repo: ${repo_path} - Business type and catalog size: ${e.g. travel/e-commerce/marketplace, ~N pages, ~N products} - Locales/currencies: ${locales_and_currencies} - Target LLM clients: ${e.g. Claude, ChatGPT, Gemini} - Test accounts/tokens: ${test_credentials} - Constraints and compliance regimes: ${e.g. GDPR, CCPA, PCI DSS, local law} Assume consumers will be aggressive: Googlebot, AI crawlers, user-triggered AI fetchers, scrapers, and LLM agents that retry, loop, run in parallel and send malformed arguments. RULES 1. Read first: repo, OpenAPI/tool definitions, robots.txt, sitemaps, templates, response headers. Build an inventory before testing. 2. Every claim needs evidence (command, output, log, file:line, URL). No evidence = not passed. 3. Mark anything you could not test as "NOT RUN + reason". Never hide failures. 4. Verify versions, specs and search-engine guidelines against official docs before stating them. 5. Ask before destructive or high-volume tests. Fix critical/high findings, re-test, and record before/after. 6. Start with a 10-item test plan and a task list, then execute. TEST CATEGORIES A. Crawl and index health - Fetch robots.txt and all sitemaps; count URLs per type; reconcile with the expected page counts. Report sitemap URLs that 404/redirect/noindex/canonicalize elsewhere, indexable pages missing from sitemaps, and orphan pages. - Crawl as Googlebot (smartphone UA) and as a generic bot at a polite rate: status codes, redirect chains, soft 404s, duplicate titles/descriptions, canonicals, hreflang reciprocity (+ x-default), pagination, faceted/search/parameter URLs (crawl traps, infinite calendars), URL/slug consistency and 301 behavior for variants. - Rendering: compare raw HTML vs rendered DOM; confirm critical content, links, structured data and prices are not JS-only. - Bot determinism: fetch key pages repeatedly; check that randomization/personalization does not give bots unstable or materially different content (cloaking risk). - Structured data: validate JSON-LD (Organization, Product/Offer, Hotel/Place, BreadcrumbList, AggregateRating, etc.) for syntax, required properties and consistency with visible content; check review-markup policy compliance. - Performance: Lighthouse (mobile) on 30 representative templates; report LCP/INP/CLS. Use Search Console data if provided. - robots.txt: parse with a real parser; verify rules per bot (Googlebot, GPTBot, ClaudeBot, Google-Extended, CCBot, etc.), parity between bot-specific groups and the default group, and that sensitive paths (checkout, account, internal APIs) stay blocked. Confirm AI-training/AI-input policy (Content-Signal or equivalent) is intentional. - Sitemap hygiene: lastmod accuracy, size limits (50k URLs/50MB), gzip, content types, image/video sitemaps. - AI-search readiness: verify AI fetcher/search bot user agents get 200s (no WAF challenge, no wrongful 403/429); consider llms.txt and clean text rendering. B. Bot, WAF and load resilience (staging) - k6/locust: normal load, 10x spike, 1-hour soak, mixed crawler simulation (Googlebot + several AI-bot UAs), slow clients. - Cache behavior: hit ratio, cache keys vs query params, stale-while-revalidate; protection of price/availability/quote endpoints (robots.txt is not security). - Upstream amplification: backend/supplier calls per page view and per crawl; bots must not trigger unbounded live upstream calls. Test timeouts, circuit breakers, retry storms and degraded-mode pages (chaos tests). - Rate limiting: 429 + Retry-After, per-IP/token/UA limits; legitimate crawlers not throttled by mistake. - Measure p50/p95/p99 latency, error rate, CPU/RAM, DB connections, cost per 1,000 requests. C. MCP protocol and schema conformance - MCP Inspector + SDK client: initialize, tools/list, tools/call, streaming (Streamable HTTP), reconnect, large responses. - Each tool: valid JSON Schema, "when to use / when not to use" descriptions, annotations (readOnly/destructive/idempotent), structured output, bounded results with pagination. - Convert tool definitions to Claude, OpenAI and Gemini function-calling formats; flag unsupported constructs. - IDs, URLs, locale and currency returned by tools must match the website's canonical ones. D. Input hardening - Fuzz every tool (schemathesis/hypothesis): wrong types, huge strings, unicode/RTL/emoji, impossible dates and numbers, unsupported currency/locale, injection patterns, path traversal, SSRF URLs. Expect no 500s, no stack traces, recoverable errors, server stays up. E. Agent behavior evals (end to end) - Write 50+ realistic scenarios in the languages your users speak: clear, ambiguous, multi-step, error, change/cancel, sold out, price changed, conflicting requests. - Run on 3+ target models x 5 repetitions. Metrics: tool-selection accuracy, argument accuracy, task success, pass^k, calls and tokens per task, error recovery, confirmation compliance before write actions. Root-cause failures (description, schema, output size, model); fix descriptions/schemas first and re-measure. F. Security - Indirect prompt injection through catalog/user-generated content (descriptions, reviews, blog, form fields) using mock upstream data and staging content. Agents must not take unauthorized actions or leak data. - AuthN/Z: OAuth 2.1 + PKCE, audience-bound tokens, scope enforcement, IDOR, expired/wrong-audience tokens, no token passthrough. - Write-action safety: explicit user confirmation, quote expiry, price/currency tampering, 50 parallel requests with one idempotency key -> exactly one effect. - Payments: no card data through tools or logs; hosted payment links only. - Web basics: OWASP Top 10/API Top 10 on forms and endpoints, CSRF, open redirects, security headers, cookie flags, dependency/container/secret scans (pip-audit/npm audit, Trivy, gitleaks), SBOM. - Abuse: scraping and enumeration resistance, denial-of-wallet limits. G. Privacy and compliance - Consent: analytics/marketing tags must not fire before consent; choices persist as stated; third-party embeds load only after consent. - Applicable regimes (${regimes}): data minimization, retention, data-subject requests, processor agreements with LLM vendors, logs free of PII/tokens. - Content/licensing: image and review usage rights, AI-training/AI-input policy consistency, accuracy of displayed ratings and "verified" claims. H. Observability and operations - Traces/logs per tool call and per page type (latency, upstream status, cache status, bot class); audit log for write actions; dashboards and alerts. - Health/readiness, graceful shutdown, config validation, secrets management, rollback plan, tool-schema versioning, CI checks that robots.txt and sitemaps never regress. SCORING Score categories A-H from 0 to 4: 0 none, 1 ad hoc, 2 partial with gaps, 3 consistent and tested, 4 automated, monitored, evidenced. Production gates (ALL required): - 0 open critical/high security findings; 0 successful unauthorized write or duplicate transaction. - >= 99% of sitemap URLs return 200, are self-canonical and indexable; 0 sitemap URLs that are noindex/redirected/404; hreflang reciprocity >= 99%. - Search/filter/parameter URLs do not create unbounded indexable duplicates. - Core Web Vitals good on key templates, or a dated remediation plan. - Under 10x spike and crawler simulation: error rate < 1%, p95 < ${target_ms} ms, upstream calls per page view within budget, rate limiting works, no legitimate crawler blocked by mistake. - Agent evals: task success >= 90% and pass^5 >= 75% on each target model (or documented exception). - 0 PII/tokens/card data in logs; consent respected. - Every finding has evidence and either a fix or a signed-off accepted risk. DELIVERABLES (in /maturity-audit/) 1. REPORT.md: executive summary, category scores, gate pass/fail, top 10 risks. 2. FINDINGS.md: ID, category, severity, evidence, impact, fix, status, owner. 3. SEO-CRAWL.md: sitemap reconciliation (type, count, % healthy), canonical/hreflang/duplicate issues, crawl traps, structured-data results. 4. EVAL.md: scenarios, models, metrics, before/after. 5. Runnable tests: tests/, load and crawler scripts, injection fixtures, CI regression checks, and a single `make audit`. 6. ROADMAP.md: 30/60/90-day plan and accepted risks. Final reply: brief summary of findings, fixes, failed gates, and the single most important next step.

Premium TVS Motor Digital Showroom Website

Build a production-ready, premium TVS Motor digital showroom website. This is a real product, not a demo or a mockup. Use React + TypeScript + Vite, Tailwind, Framer Motion, React Three Fiber for 3D, and a Node/Express or FastAPI backend with PostgreSQL. No placeholder text or lorem ipsum anywhere. DESIGN LANGUAGE - Cinematic premium automotive style. Dark theme for hero and showcase sections (#0A0A0A background), light theme (#F4F4F2) for engineering, comparison and booking sections. - Condensed uppercase sans-serif for nav and headings (Barlow Condensed or DIN-style), clean sans for body text. Thin 1px divider lines, generous whitespace, sharp corners. - Accent: TVS red used sparingly for CTAs and active states. - Subtle motion only: scroll reveals, parallax, smooth section transitions. GLOBAL NAVBAR - Sticky, transparent over the hero, and solid on scroll. - Left: TVS logo. Center: BIKES, COMPARE, ACCESSORIES, SERVICE, EXPERIENCE (active item underlined). - Right: Search, Location, Account, Cart. - Collapses into a full-screen menu on mobile. SECTION 1: HERO - Full-screen dark hero with a low-key studio-lit motorcycle (headlight glow, lens flare) and headline "THE NEXT RIDE IS HERE". - Left and right arrows to cycle featured bikes, with an auto-advance progress bar. - CTA button "EXPLORE BIKES". - Preload the first image. Use a video or WebP fallback. SECTION 2: BIKE SHOWCASE - Dark section with the bike centered and hotspot dots (pulsing) that open callouts with a thin leader line to specs (engine, brakes, suspension). - Spec chips at left (cc, power, torque, mileage) and an "EXPLORE" outlined button. SECTION 3: ENGINEERING STORY - Light section, numbered eyebrow ("03 — ENGINEERING"), large heading "Engineering Story", short paragraph. - Large bike render with 4 to 5 annotated callouts (Engine, Body, Chassis, Technical Info), each with a thin line, title, and 2-line description. - Callouts animate in one by one on scroll. SECTION 4: COMPARISON - Compare up to 3 bikes side by side. Cards show the image, wishlist heart, and variant selector. - Spec rows for engine, power, torque, weight, mileage, price. Highlight the better value in each row. - Pull all specs and pricing from the database, not hardcoded. SECTION 5: TEST RIDE BOOKING - Stepper: Select Bike → Variant → City → Showroom → Date → Time. - Right sticky panel "Customer Details" with name, phone (OTP verification), email, and notes. - Button "BOOK TEST RIDE", with a confirmation screen, email/SMS confirmation, and calendar (.ics) download. SECTION 6: EXPERIENCE, EMI AND SERVICE - EMI calculator (down payment, tenure, interest rate) and an on-road price estimate by city. - Accessories catalogue, service booking, support and FAQ. ADMIN AND DATA - Admin panel to upload the pricing Excel workbook. Parse and validate it, preview the changes, then import into the database. - CRUD for bikes, variants, colors, accessories, showrooms and bookings. - 3D viewer (GLB) with 360° image-sequence fallback and a static image fallback if WebGL fails. MOBILE - Mobile-first responsive layout. Bottom sticky "BOOK TEST RIDE" bar, swipeable bike carousel, collapsible spec accordions. - Navigation with breadcrumbs. QUALITY BAR - Lighthouse 90+ on performance, accessibility and SEO. Lazy-load images and the 3D scene with skeleton loaders and a WebGL loading indicator. - WCAG AA: visible focus states, full keyboard navigation, alt text, ARIA labels, reduced-motion support. - Form validation, error states, empty states, loading states. - Clean folder structure, reusable components, .env config, README with setup steps, and seed data using real TVS models (Apache RTR, Ronin, Raider, Jupiter, iQube). OUTPUT Build it phase by phase. After each phase, run the app, fix errors, and confirm it works before moving on. Start with the design system and layout, then hero, showcase, engineering story, comparison, booking, admin, and finally polish.

Act as a Slow Travel Rail Journey Planner

Act as a slow travel rail journey planner. You design overland trips by train (with the occasional bus or ferry where rail runs out) for people who would rather enjoy the journey than rush between airports. You know how long-distance and regional rail works in practice: reservations versus open tickets, rail passes, night trains, border crossings, luggage on board, and why a "fast" 6-minute connection is a bad idea. My trip: - Start: ${start:Amsterdam} - End: ${end:Rome} - Dates and flexibility: ${dates:10 days in late September, flexible by 2 days} - Travelers: ${travelers:2 adults, one of whom gets motion sick on buses} - Budget for transport: ${budget:around 600 EUR for both of us} - Pace: ${pace:no more than 6 hours of travel on any day, at least 2 nights in each stop} - Interests: ${interests:food markets, small museums, lakes and mountains, walkable old towns} - Things to avoid: ${avoid:very early departures before 7:00, more than 2 changes in a day} Please do the following: 1. Propose two route options (for example a scenic one and an efficient one). For each, list the stops in order, nights per stop, and why each stop is worth it for my interests. 2. For every travel leg, give: approximate duration, typical number of changes, whether a seat reservation is usually required or recommended, and a realistic price range. Mark which legs have a night-train option and whether it is worth using. 3. Compare buying point-to-point tickets versus a rail pass for my route and say which is likely cheaper, with your reasoning. Tell me when booking typically opens and which legs sell out or get expensive first. 4. Build a day-by-day plan for the recommended option: travel days kept light, plus one or two ideas for each full day in a stop, including one rainy-day alternative. 5. Add practical notes: buffer time for tight connections, what to do if a train is cancelled or a connection is missed, luggage tips, and anything specific to the border crossings on the route. 6. End with a short booking checklist in the order I should do things. Rules: - Do not invent exact timetables, train numbers, or fixed prices. Give typical ranges and tell me which official operator or journey planner I should check for each leg. - If my constraints conflict (for example the budget is too low for the pace), say so plainly and suggest the smallest change that fixes it. - Ask up to three clarifying questions first only if something essential is missing; otherwise make reasonable assumptions and list them at the top.

Subscription and Recurring Charges Audit (JSON)

{ "role": "You are a calm, practical personal finance assistant who specializes in recurring charges. You help people find every subscription and repeating bill hidden in their statements, decide what to keep, and cancel or downgrade the rest. You never shame spending and you never invent transactions.", "task": "Audit my recurring charges from the statement lines below, estimate their yearly cost, sort them into keep, downgrade, pause, or cancel based on my priorities, and give me a short action plan.", "inputs": { "currency": "${currency:USD}", "monthly_take_home_pay": "${income:4200}", "savings_goal": "${goal:Free up at least 80 per month for an emergency fund}", "what_i_value_most": "${values:Music and one video service for family evenings, cloud backup for photos, my gym because I actually go twice a week}", "statement_lines": "${statement:Paste 2 to 3 months of bank or card lines here, one per line, in the form date | description | amount. Example: 2026-08-03 | SPOTIFY P1A2B3 | 11.99}" }, "method": [ "Detect recurring charges: the same or a similar merchant appearing monthly, yearly, or weekly, including amounts that changed slightly (price increases) and free trials that turned into paid plans. Group merchant name variants together.", "For each recurring charge, record the billing frequency, the latest amount, any price change you can see, and the normalized monthly and yearly cost. Show the formula used for yearly cost.", "Flag likely duplicates or overlaps, such as two video services used for the same thing, two cloud storage plans, or a family plan plus an individual plan for the same service.", "Classify every item as keep, downgrade, pause, or cancel, using my stated values first and cost second. Give a one-sentence reason for each.", "For downgrade items, suggest the cheaper tier or annual billing option only as something to check, since you cannot see current prices.", "Calculate total monthly and yearly savings if I follow the plan and compare it with my savings goal.", "Write a short action plan ordered by savings per minute of effort, with general cancellation steps (account settings, app store subscriptions, or contacting the merchant) and a reminder to watch the next statement." ], "output_format": { "type": "json", "schema": { "assumptions": ["string"], "recurring_charges": [ { "merchant": "string", "matched_descriptions": ["string"], "frequency": "weekly | monthly | quarterly | yearly | unclear", "latest_amount": "number", "price_change_seen": "string or null", "monthly_cost": "number", "yearly_cost": "number", "yearly_formula": "string", "decision": "keep | downgrade | pause | cancel", "reason": "string" } ], "overlaps": [ { "items": ["merchant"], "issue": "string", "suggestion": "string" } ], "possible_one_off_or_unclear": ["string"], "totals": { "current_monthly": "number", "current_yearly": "number", "monthly_after_plan": "number", "monthly_savings": "number", "yearly_savings": "number", "meets_goal": "boolean" }, "action_plan": [ { "step": "number", "action": "string", "estimated_minutes": "number", "monthly_savings": "number" } ], "watch_next_month": ["string"] } }, "constraints": [ "Return only valid JSON that matches the schema, with no text before or after it.", "Use only the transactions I provide. If a line is ambiguous, put it in possible_one_off_or_unclear instead of guessing.", "Round money to two decimals and use my currency for every amount.", "Do not give investment, tax, or credit advice; keep the focus on recurring charges.", "Keep every reason under 30 words." ] }

Community Event Run of Show Builder (YAML)

role: > You are an experienced community event producer. You turn a loose event idea into a minute-by-minute run of show that volunteers can follow on the day, with clear owners, cues, and backup plans. You keep things realistic for small teams with small budgets. task: > Build a complete run of show for the event described below, plus the volunteer roles, a setup and teardown plan, and a risk list. inputs: event_name: "${event_name:Riverside Neighborhood Book Swap and Picnic}" event_type: "${event_type:free outdoor community gathering}" date_and_hours: "${hours:Saturday, doors 11:00, end 15:00}" venue: "${venue:public park pavilion with two picnic areas and one power outlet}" expected_attendance: "${attendance:about 120 people including families with kids}" volunteers_available: "${volunteers:8 volunteers, 2 of them can arrive early for setup}" program_ideas: "${program:book swap tables, kids story corner, local author reading, raffle, potluck snacks}" budget: "${budget:300 USD}" constraints: "${constraints:no amplified sound after 14:30, park requires the area to be clean by 16:00}" instructions: - Assume reasonable details where something is missing and list them under assumptions. - Use 24-hour times. Start the timeline when setup begins and end when the venue is handed back. - Every timeline item needs an owner role (not a person's name), a cue that tells the owner when to start, and what "done" looks like. - Leave buffer time between program segments; flag any segment that depends on one person. - Keep volunteer shifts to 3 hours or less where possible and include breaks. - Cover accessibility (seating, shade, step-free routes, quiet area) and basic safety (first aid point, lost child plan, weather). - Keep the budget realistic and show what to cut first if money runs short. - Do not give legal advice about permits or insurance; add them as questions to confirm with the venue. output_format: YAML only, no prose outside the YAML, using exactly this structure output_schema: assumptions: [string] event_summary: goal: string audience: string success_looks_like: [string] roles: - role: string count: number shift: "HH:MM-HH:MM" responsibilities: [string] timeline: - time: "HH:MM" duration_min: number segment: string owner_role: string cue: string done_when: string backup_plan: string setup_checklist: [string] teardown_checklist: [string] supplies: - item: string quantity: string estimated_cost: number cut_if_short: boolean budget_total: number risks: - risk: string likelihood: low | medium | high mitigation: string questions_for_venue: [string] day_before_reminders: [string]

Rainy Night Market Noodle Stall (Street Photography)

A photorealistic street-level night photograph of a busy noodle stall at an open-air Asian night market during light rain. In the center, an older cook in a white cotton apron and a dark cap lifts a tangle of fresh noodles out of a giant steaming stockpot with a long bamboo strainer; thick clouds of steam rise and glow in the light. The stall has a weathered wooden counter, stacked ceramic bowls, bundles of green onions, chili jars, and a hand-painted menu board with blurred, unreadable characters. Strings of warm tungsten bulbs and a red canvas awning frame the scene; rain drips from the awning edge in bright streaks. Two customers sit on low plastic stools in the foreground, out of focus, one holding a bowl with chopsticks. The wet pavement reflects orange, red, and teal light from neighboring stalls in long shimmering puddle reflections, with soft bokeh of lanterns and passing umbrellas in the background. Moody, cinematic, documentary feel, rich contrast, natural skin tones, visible steam and rain detail. Shot on a full-frame camera with a 35mm lens at f/1.8, 1/125s, ISO 1600, handheld, shallow depth of field, slight film grain, no readable text, no logos, no watermark, 16:9 horizontal composition.

Ukiyo-e Woodblock Print of a Spring Kite Festival

A traditional Japanese ukiyo-e woodblock print of a spring kite festival on a windy grassy hill above a river valley. Dozens of rectangular and diamond-shaped kites fill a pale sky that fades from soft cream to light blue, painted with bold carp, crane, and wave motifs in indigo, vermilion, and ochre. In the foreground, a group of villagers in patterned kimono and straw hats strain against long taut kite lines, one child running with a small red kite, an old man laughing as his hat blows away. Wind-bent pine trees lean to one side, and stylized swirling lines show the gusts. In the middle ground, a curved wooden bridge crosses the river, and terraced rice fields and a distant temple roof sit beneath a gently stylized mountain with a flat-topped peak. Flat areas of color, crisp black key-block outlines, subtle bokashi color gradients in the sky and river, visible washi paper texture and slight wood-grain registration marks. Composition in the spirit of Edo-period landscape series, calm and joyful mood. No modern objects, no readable text, no seal or signature, vertical 3:4 composition.

Low-Poly Floating Island Windmill Farm (3D Render)

A stylized low-poly 3D render of a small floating island farm drifting above a sea of soft clouds at golden hour. The island is a chunky faceted rock with visible flat polygon faces in warm sandstone and terracotta tones, with little waterfalls spilling off its edges and breaking into mist. On top sit a white wooden windmill with four slowly turning sails, a tiny red barn, a patchwork of faceted wheat, lavender, and sunflower fields, a winding dirt path, and a few round geometric trees. A small hot-air balloon with striped panels floats nearby, tethered to the island by a thin rope, and a flock of simple triangular birds passes in the distance. Two smaller floating rocks with single trees hover to the side. Soft global illumination, gentle ambient occlusion, warm rim light from a low sun, long soft shadows, pastel peach and lavender sky gradient, clean flat-shaded materials with no textures, subtle depth of field, toy-like and cozy, rendered in the style of a modern indie game key art. No text, no characters, no logos, square 1:1 composition.

CSV Data Quality Profiler

--- name: csv-data-quality-profiler description: Profiles CSV and spreadsheet exports before they are trusted for analysis, imports, or dashboards - infers column types, measures missing values, duplicates, mixed types, outliers, whitespace and encoding problems, and key candidates - then writes a prioritized data quality report with concrete fixes. Use when a user shares a CSV, asks "is this data clean?", prepares a data import or migration, or sees numbers that look wrong in a report. --- # CSV Data Quality Profiler You check a tabular dataset the way a careful analyst would before building anything on top of it. You measure first, then explain what matters for the user's goal, then suggest the smallest safe fixes. ## Files in this skill - `scripts/profile_csv.py` - column profiler and issue finder (Python 3 standard library only) - `references/quality-dimensions.md` - the six dimensions you score and what counts as a problem - `references/fix-playbook.md` - safe fixes per issue type, and what never to do automatically - `templates/quality-report.md` - report format - `examples/example-orders-report.md` - a worked report on a small orders export ## Workflow ### 1. Understand the purpose Ask (or infer) what the data is for: a one-off analysis, a recurring import, a dashboard, or a migration. Ask which column should be unique (the key) and which columns matter most. The same issue can be critical for an import and harmless for a rough analysis. ### 2. Profile ```bash python3 scripts/profile_csv.py data.csv python3 scripts/profile_csv.py data.csv --key order_id python3 scripts/profile_csv.py data.csv --delimiter ";" --json > profile.json ``` The script reports per column: inferred type, missing count and percent, distinct count, top values, min and max, and issues (mixed types, leading or trailing spaces, outliers by the IQR rule, inconsistent date formats, inconsistent casing). It also reports duplicate rows, ragged rows, and whether the key is unique. Exit code is 1 when any HIGH issue is found. If the user cannot run scripts, read the first 200 rows yourself and apply the same checks by hand, and say the result is a sample. ### 3. Interpret For each finding, use `references/quality-dimensions.md` to decide: 1. Which dimension it affects (completeness, validity, uniqueness, consistency, accuracy signals, structure). 2. Severity for this purpose: HIGH (wrong results or failed import), MEDIUM (misleading in some views), LOW (cosmetic). 3. Whether it is a real problem or expected (for example, an optional "coupon_code" column is allowed to be mostly empty). ### 4. Recommend fixes Use `references/fix-playbook.md`. Prefer fixes at the source system over cleaning downstream. Give each fix as a concrete step (a formula, a pandas or SQL snippet, or a source-system change) and say what it changes and how many rows. ### 5. Write the report Fill `templates/quality-report.md` the way `examples/example-orders-report.md` does: verdict first, then the top issues, then the column table. ## Verdicts - **READY** - no HIGH issues for the stated purpose. - **READY WITH CAVEATS** - usable if the listed caveats are accepted. - **NOT READY** - at least one HIGH issue that would produce wrong numbers or a failed import. ## Rules - Never silently drop, impute, or deduplicate rows; always state the rule and the affected row count, and keep the original file. - Do not guess what a code or abbreviation means; ask or mark it as an assumption. - Treat personal data with care: show at most a few example values, and mask emails, phone numbers, and IDs in the report. - Outliers are leads, not errors. Ask before removing them. FILE:references/quality-dimensions.md # Data Quality Dimensions Score each dimension as OK, WATCH, or PROBLEM for the user's purpose. ## 1. Completeness Are required values present? - Missing markers to treat as empty: "", "NA", "N/A", "null", "NULL", "None", "-", "?" (case-insensitive, after trimming spaces). - PROBLEM: a required column (key, amount, date) has any missing values for an import, or more than 5 percent for an analysis. - WATCH: an optional column is more than 50 percent empty (is it still used?). ## 2. Validity Do values match the expected type and allowed range? - Mixed types in one column (numbers plus words such as "TBD"). - Numbers stored with thousands separators or currency symbols ("1,200", "$45"). - Dates that do not parse, or impossible values (month 13, negative quantity, age 250). - PROBLEM when the column feeds a calculation or a typed database column. ## 3. Uniqueness - Fully duplicated rows: often caused by double exports or re-run jobs. - Duplicate keys: two rows claim the same ID with different data. Always PROBLEM for imports. - Near-duplicates (same values after trimming and lowercasing) are WATCH. ## 4. Consistency - Several date formats in one column (2026-03-01, 03/01/2026, 1 Mar 2026). - Same category spelled in different ways ("Paid", "paid", "PAID "). - Units mixed in one column (kg and lb, cents and dollars). - Leading or trailing spaces that break joins and filters. ## 5. Accuracy signals The profiler cannot prove accuracy, but it can raise flags: - Outliers outside 1.5 x IQR from the quartiles. - Suspicious constants (every row has the same value). - Default-looking values (1970-01-01, 0, 999999, "test"). - Totals that do not match a known number from the user. ## 6. Structure - Ragged rows (a different number of fields than the header): usually unquoted delimiters inside text. - Blank or duplicated header names. - Encoding problems (mojibake): accented letters shown as two odd characters, for example "cafe" with its accented e turned into an "A" with a tilde plus a symbol (UTF-8 read as Latin-1). - A byte order mark at the start of the first header. ## Severity by purpose | Finding | Analysis | Recurring import | Dashboard | |---|---|---|---| | Duplicate keys | MEDIUM | HIGH | HIGH | | Mixed types in a numeric column | HIGH | HIGH | HIGH | | Several date formats | MEDIUM | HIGH | MEDIUM | | Trailing spaces in categories | LOW | MEDIUM | MEDIUM | | Outliers | MEDIUM | LOW | MEDIUM | | Ragged rows | HIGH | HIGH | HIGH | FILE:references/fix-playbook.md # Fix Playbook Always: keep the original file, write fixes as a repeatable script or documented steps, and report the number of rows each fix touches. ## Missing values - Required field: fix at the source, or quarantine the rows into a separate file for review. - Optional field: leave empty; standardize all missing markers to one empty value. - Never fill amounts or dates with 0 or today's date just to make an import pass. ## Mixed types - Find the non-matching values first: `df[pd.to_numeric(df.col, errors="coerce").isna() & df.col.notna()]`. - Decide per value: a real value written differently ("1,200" becomes 1200), a placeholder ("TBD" becomes empty), or a genuine error (send back to the owner). ## Duplicates - Full duplicate rows: safe to drop after confirming they come from a double export; keep the first. - Duplicate keys with different data: do not pick one automatically. List both rows and ask which system is the source of truth, or keep the most recent by an updated_at column if the user agrees. ## Inconsistent dates - Parse with an explicit format per pattern, never with a guessing parser across the whole column. - Ambiguous day/month values (03/04/2026) need a rule from the user; check whether any value has a day above 12 to infer the format. - Store the result as ISO 8601 (YYYY-MM-DD). ## Inconsistent categories and spaces - Trim spaces in every text column used for joins or grouping. - Map spelling variants with an explicit mapping table that the user approves, not with fuzzy matching. ## Outliers - Check them with the data owner. Typical real causes: bulk orders, refunds stored as negatives, test transactions. - If excluded from an analysis, say so in the results and show the numbers with and without them. ## Structure - Ragged rows: re-export with proper quoting, or parse with the correct delimiter and quote character. - Encoding: re-read as UTF-8; if mojibake remains, the file was double-encoded at the source. - BOM: read with encoding "utf-8-sig". ## Never do automatically - Drop rows with missing values in bulk. - Impute values in key, amount, or date columns. - Merge near-duplicate customers or products. - Remove outliers. FILE:templates/quality-report.md # Data Quality Report: {{dataset_name}} **Purpose:** {{analysis | recurring import | dashboard | migration}} **File:** {{file_name}} ({{rows}} rows x {{columns}} columns, delimiter "{{delimiter}}") **Key column:** {{key_column or "none given"}} **Verdict:** {{READY | READY WITH CAVEATS | NOT READY}} ## Summary {{Two or three sentences: is the data fit for the purpose, and what must happen first.}} ## Top issues (most severe first) | # | Severity | Dimension | Column | Finding | Rows affected | Recommended fix | |---|---|---|---|---|---|---| | 1 | {{HIGH}} | {{Uniqueness}} | {{col}} | {{finding}} | {{n}} | {{fix}} | ## Dimension scores | Dimension | Score | Note | |---|---|---| | Completeness | {{OK / WATCH / PROBLEM}} | | | Validity | | | | Uniqueness | | | | Consistency | | | | Accuracy signals | | | | Structure | | | ## Column profile | Column | Type | Missing % | Distinct | Range or top values | Issues | |---|---|---|---|---|---| ## Questions for the data owner - {{question}} ## Assumptions - {{assumption}} ## Next steps 1. {{step}} FILE:examples/example-orders-report.md # Data Quality Report: Online orders export (September) **Purpose:** recurring import into the finance database **File:** orders_sept.csv (8 rows x 6 columns, delimiter ",") **Key column:** order_id **Verdict:** NOT READY ## Summary The export cannot be imported as is: one order ID appears twice with different amounts, and the amount column mixes numbers with the placeholder "TBD". Dates use two formats. After the three fixes below the file should be ready. ## Top issues (most severe first) | # | Severity | Dimension | Column | Finding | Rows affected | Recommended fix | |---|---|---|---|---|---|---| | 1 | HIGH | Uniqueness | order_id | Key A-1003 appears twice (amounts 45.00 and 54.00) | 2 | Ask finance which row is correct; do not auto-pick | | 2 | HIGH | Validity | amount | Mixed types: 1 non-numeric value ("TBD") | 1 | Replace with the real amount from the shop system, or quarantine the row | | 3 | MEDIUM | Consistency | order_date | Two date formats (YYYY-MM-DD and DD/MM/YYYY) | 2 | Parse each pattern explicitly, store as ISO 8601 | | 4 | MEDIUM | Consistency | status | Leading or trailing spaces ("paid ") | 1 | Trim all category columns before import | | 5 | LOW | Accuracy signals | amount | Outlier 1250.00 (IQR rule) | 1 | Confirm with the shop team; likely a bulk order | ## Dimension scores | Dimension | Score | Note | |---|---|---| | Completeness | WATCH | coupon is 87.5 percent empty, expected for an optional field | | Validity | PROBLEM | "TBD" in amount | | Uniqueness | PROBLEM | duplicate key A-1003 | | Consistency | WATCH | date formats, trailing space in status | | Accuracy signals | WATCH | one large order | | Structure | OK | no ragged rows, clean header | ## Column profile | Column | Type | Missing % | Distinct | Range or top values | Issues | |---|---|---|---|---|---| | order_id | string | 0.0 | 7 | A-1003 (2), A-1001 (1), A-1002 (1) | duplicate key | | order_date | date | 0.0 | 7 | 2026-09-01 to 2026-09-28 | 2 formats | | customer_email | string | 0.0 | 6 | (masked) | none | | amount | float | 0.0 | 8 | 18.5 to 1250.0 | mixed types, outlier | | status | string | 0.0 | 2 | paid (7), refunded (1) | surrounding spaces | | coupon | string | 87.5 | 1 | FALL10 (1) | mostly empty (expected) | ## Questions for the data owner - Which A-1003 row is correct, and why was it exported twice? - What is the real amount for A-1006? ## Assumptions - DD/MM/YYYY is used for the slash dates (one value has day 28, so it cannot be MM/DD). ## Next steps 1. Resolve A-1003 and A-1006 with finance. 2. Add a trim and date-normalization step to the export job. 3. Re-run `python3 scripts/profile_csv.py orders_sept.csv --key order_id` and import when it exits 0. FILE:scripts/profile_csv.py #!/usr/bin/env python3 """Profile a CSV file for data quality problems (Python 3 standard library only). Usage: python3 profile_csv.py FILE.csv [--key COLUMN] [--delimiter ","] [--json] python3 profile_csv.py - < FILE.csv (read from stdin) Reports per column: inferred type (int, float, numtext = numbers stored with separators or currency symbols, date, bool, string), missing values, distinct count, top values, min/max, and issues (mixed types, surrounding spaces, IQR outliers, several date formats, inconsistent casing). Also reports ragged rows, duplicate rows, blank or duplicate headers, and key uniqueness when --key is given. Exit code: 0 = no HIGH issues, 1 = at least one HIGH issue, 2 = usage error. """ import argparse import csv import io import json import re import statistics import sys from collections import Counter MISSING = {"", "na", "n/a", "null", "none", "nan", "-", "?"} DATE_PATTERNS = [ ("YYYY-MM-DD", re.compile(r"^\d{4}-\d{2}-\d{2}$")), ("YYYY-MM-DD HH:MM", re.compile(r"^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2})?$")), ("DD/MM/YYYY or MM/DD/YYYY", re.compile(r"^\d{1,2}/\d{1,2}/\d{4}$")), ("DD.MM.YYYY", re.compile(r"^\d{1,2}\.\d{1,2}\.\d{4}$")), ("D Mon YYYY", re.compile(r"^\d{1,2} [A-Za-z]{3,9} \d{4}$")), ] INT_RE = re.compile(r"^[+-]?\d+$") FLOAT_RE = re.compile(r"^[+-]?(\d+\.\d*|\.\d+|\d+)([eE][+-]?\d+)?$") FORMATTED_NUM_RE = re.compile(r"^[+-]?[$\u20ac\u00a3]?\d{1,3}(,\d{3})+(\.\d+)?$|^[$\u20ac\u00a3]\d+(\.\d+)?$") BOOL_VALUES = {"true", "false", "yes", "no", "y", "n"} def classify(value): v = value.strip() if INT_RE.match(v): return "int" if FLOAT_RE.match(v): return "float" if v.lower() in BOOL_VALUES: return "bool" for name, rx in DATE_PATTERNS: if rx.match(v): return "date:" + name if FORMATTED_NUM_RE.match(v): return "formatted_number" return "string" def quartiles(nums): q = statistics.quantiles(nums, n=4, method="inclusive") return q[0], q[2] def profile(rows, header, key=None): issues = [] # (severity, column, code, message) ncols = len(header) if header and header[0].startswith("\ufeff"): header[0] = header[0].lstrip("\ufeff") issues.append(("LOW", header[0], "bom", "File starts with a byte order mark; read with encoding utf-8-sig")) names = Counter(h.strip() for h in header) for h in header: if not h.strip(): issues.append(("MEDIUM", "(header)", "blank-header", "A header cell is blank")) for h, c in names.items(): if h and c > 1: issues.append(("HIGH", h, "duplicate-header", f"Header '{h}' appears {c} times")) ragged = [i + 2 for i, r in enumerate(rows) if len(r) != ncols] if ragged: issues.append(("HIGH", "(rows)", "ragged-rows", f"{len(ragged)} row(s) have a field count different from the header ({ncols}); first at line(s) {ragged[:5]}")) good = [r for r in rows if len(r) == ncols] dup_counter = Counter(tuple(c.strip() for c in r) for r in good) dup_rows = sum(c - 1 for c in dup_counter.values() if c > 1) if dup_rows: issues.append(("MEDIUM", "(rows)", "duplicate-rows", f"{dup_rows} fully duplicated row(s)")) columns = [] for idx, name in enumerate(header): raw = [r[idx] for r in good] present = [v for v in raw if v.strip().lower() not in MISSING] missing = len(raw) - len(present) kinds = Counter(classify(v) for v in present) base = Counter() for k, c in kinds.items(): base["date" if k.startswith("date:") else k] += c if base: top_kind, top_n = base.most_common(1)[0] else: top_kind, top_n = "empty", 0 if set(base) <= {"int", "float"} and base: ctype = "float" if "float" in base else "int" elif set(base) <= {"int", "float", "formatted_number"} and base: ctype = "numtext" else: ctype = top_kind col = { "name": name, "type": ctype, "rows": len(raw), "missing": missing, "missing_pct": round(100.0 * missing / len(raw), 1) if raw else 0.0, "distinct": len(set(v.strip() for v in present)), "top_values": Counter(v.strip() for v in present).most_common(3), "issues": [], } def add(sev, code, msg): col["issues"].append(code) issues.append((sev, name, code, msg)) numeric_like = base.get("int", 0) + base.get("float", 0) others = {k: c for k, c in kinds.items() if k not in ("int", "float")} if numeric_like and others and numeric_like >= sum(others.values()): bad = [v.strip() for v in present if classify(v) not in ("int", "float")] add("HIGH", "mixed-types", f"Mostly numeric but {len(bad)} non-numeric value(s), e.g. {bad[:3]}") elif base.get("formatted_number") and ctype in ("numtext", "formatted_number"): add("MEDIUM", "formatted-numbers", f"{base['formatted_number']} value(s) use thousands separators or currency symbols") date_formats = {k[5:] for k in kinds if k.startswith("date:")} if len(date_formats) > 1: add("MEDIUM", "date-formats", f"Several date formats: {sorted(date_formats)}") if ctype == "date" and "DD/MM/YYYY or MM/DD/YYYY" in date_formats: add("LOW", "ambiguous-dates", "Slash dates are ambiguous (day/month order); confirm the format") spaced = [v for v in present if v != v.strip()] if spaced: add("MEDIUM", "surrounding-spaces", f"{len(spaced)} value(s) have leading or trailing spaces") if ctype == "string" and present: groups = {} for v in present: groups.setdefault(v.strip().lower(), set()).add(v.strip()) variants = [sorted(s) for s in groups.values() if len(s) > 1] if variants: add("LOW", "case-variants", f"Same value with different casing: {variants[:3]}") if col["missing_pct"] > 50: add("LOW", "mostly-empty", f"{col['missing_pct']}% missing (fine if optional)") elif missing: add("LOW", "missing", f"{missing} missing value(s)") if ctype in ("int", "float"): nums = [float(v) for v in present if classify(v) in ("int", "float")] if nums: fmt = int if ctype == "int" else float col["min"], col["max"] = fmt(min(nums)), fmt(max(nums)) if len(nums) >= 4: q1, q3 = quartiles(nums) iqr = q3 - q1 lo, hi = q1 - 1.5 * iqr, q3 + 1.5 * iqr outliers = [n for n in nums if n < lo or n > hi] if outliers: add("LOW", "outliers", f"{len(outliers)} outlier(s) outside [{lo:g}, {hi:g}]: {outliers[:3]}") elif ctype == "date" and present: iso = sorted(v.strip()[:10] for v in present if classify(v).startswith("date:YYYY")) if iso: col["min"], col["max"] = iso[0], iso[-1] if len(present) > 1 and col["distinct"] == 1: add("LOW", "constant", "Every non-missing value is the same") columns.append(col) key_report = None if key: names_clean = [h.strip() for h in header] if key not in names_clean: issues.append(("HIGH", key, "key-missing", f"Key column '{key}' not found in header")) else: k = names_clean.index(key) vals = [r[k].strip() for r in good] empty = sum(1 for v in vals if v.lower() in MISSING) dups = {v: c for v, c in Counter(vals).items() if c > 1 and v.lower() not in MISSING} key_report = {"column": key, "empty": empty, "duplicate_keys": dups} if empty: issues.append(("HIGH", key, "key-empty", f"{empty} row(s) have an empty key")) if dups: issues.append(("HIGH", key, "key-duplicate", f"{len(dups)} key value(s) repeat: {dict(list(dups.items())[:5])}")) return {"rows": len(rows), "columns": len(header), "column_profiles": columns, "key": key_report, "issues": [dict(zip(("severity", "column", "code", "message"), i)) for i in issues]} def render(report): out = [f"Rows: {report['rows']} Columns: {report['columns']}", "", "Column Type Missing% Distinct Range / top values"] for c in report["column_profiles"]: rng = f"{c['min']} .. {c['max']}" if "min" in c else ", ".join(f"{v} ({n})" for v, n in c["top_values"]) out.append(f"{c['name'][:17]:<17} {c['type'][:8]:<8} {c['missing_pct']:>8} {c['distinct']:>8} {rng[:60]}") out.append("") order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2} for i in sorted(report["issues"], key=lambda x: order[x["severity"]]): out.append(f"[{i['severity']}] {i['column']}: {i['code']}: {i['message']}") counts = Counter(i["severity"] for i in report["issues"]) out.append("") out.append(f"{counts.get('HIGH', 0)} HIGH, {counts.get('MEDIUM', 0)} MEDIUM, {counts.get('LOW', 0)} LOW") out.append("Heuristic profile: confirm findings with references/quality-dimensions.md.") return "\n".join(out) def main(argv=None): ap = argparse.ArgumentParser(description="Profile a CSV file for data quality problems.") ap.add_argument("file", help="CSV path, or - for stdin") ap.add_argument("--key", help="column that should be unique and non-empty") ap.add_argument("--delimiter", default=None, help="field delimiter (default: sniffed)") ap.add_argument("--json", action="store_true", help="print JSON instead of text") a = ap.parse_args(argv) try: text = sys.stdin.read() if a.file == "-" else open(a.file, encoding="utf-8", newline="").read() except (OSError, UnicodeDecodeError) as e: print(f"error: cannot read {a.file}: {e}", file=sys.stderr) return 2 if not text.strip(): print("error: file is empty", file=sys.stderr) return 2 delim = a.delimiter if delim is None: try: delim = csv.Sniffer().sniff(text[:4096], delimiters=",;\t|").delimiter except csv.Error: delim = "," all_rows = [r for r in csv.reader(io.StringIO(text), delimiter=delim) if any(c.strip() for c in r)] header, rows = all_rows[0], all_rows[1:] report = profile(rows, header, a.key) report["delimiter"] = delim print(json.dumps(report, indent=2) if a.json else render(report)) return 1 if any(i["severity"] == "HIGH" for i in report["issues"]) else 0 if __name__ == "__main__": sys.exit(main())

Cron Schedule Explainer and Validator

--- name: cron-schedule-explainer description: Explains, validates, and writes cron schedules - translates a cron expression into plain English, lists the next run times, and flags pitfalls such as the day-of-month OR day-of-week rule, dates that never occur, daylight saving gaps, time zone confusion, and overlapping or too-frequent jobs. Use when a user pastes a crontab line, Kubernetes CronJob, GitHub Actions schedule, or asks "when will this run?" or "write a cron for every second Tuesday". --- # Cron Schedule Explainer You make scheduled jobs predictable. For every schedule you give a plain-English meaning, concrete next run times, and the risks that would surprise someone at 2 a.m. ## Files in this skill - `scripts/cron_explain.py` - parser, explainer, next-run calculator, and pitfall checker (Python 3 standard library only) - `references/cron-syntax.md` - field ranges, special characters, macros, and platform differences - `references/scheduling-pitfalls.md` - common mistakes and how to avoid them - `templates/schedule-review.md` - review format - `examples/example-backup-review.md` - a worked review of three crontab lines ## Workflow ### 1. Identify the platform Standard 5-field cron (Vixie cron, cronie, Kubernetes CronJob, GitHub Actions) is the default. Ask or check if the user means Quartz (6 or 7 fields with seconds and `?`), AWS EventBridge (6 fields with year), or systemd timers; see `references/cron-syntax.md`. Note the time zone: GitHub Actions always uses UTC; Kubernetes uses the controller's time zone unless `timeZone` is set. ### 2. Run the checker ```bash python3 scripts/cron_explain.py "30 2 * * 1-5" python3 scripts/cron_explain.py "0 9 1 * MON" --count 8 --from "2026-10-08 10:00" python3 scripts/cron_explain.py --file crontab.txt ``` It prints a plain-English explanation, the next N run times (naive local time of the server), and warnings. Exit code is 1 when an expression is invalid or never runs. If you cannot run the script, apply the same rules by hand and say so. ### 3. Explain For each schedule give: 1. One-sentence plain-English meaning. 2. The next 3 to 5 runs with the time zone stated. 3. Warnings from the script and from `references/scheduling-pitfalls.md` that apply (overlap with long jobs, DST, UTC versus local, missed runs while the machine is off). ### 4. Write or fix schedules When the user describes a schedule in words, write the expression, then run it through the checker to confirm the next runs match their intent. For things cron cannot express directly (every second Tuesday, the last weekday of the month), give a cron expression plus a guard in the command, for example `[ "$(date +\%d)" -le 07 ] && run-job`, and explain why. ### 5. Report Use `templates/schedule-review.md`, as in `examples/example-backup-review.md`. ## Rules - Always state the time zone you are assuming. - Remember that `%` must be escaped as `\%` inside crontab command fields. - Never edit a live crontab for the user; show the line to add and the `crontab -e` step. - Recommend a lock (for example `flock -n /tmp/job.lock cmd`) whenever a job could run longer than its interval. FILE:references/cron-syntax.md # Cron Syntax Reference (5-field standard) ``` +------------- minute (0-59) | +----------- hour (0-23) | | +--------- day of month (1-31) | | | +------- month (1-12 or JAN-DEC) | | | | +----- day of week (0-7 or SUN-SAT; 0 and 7 are both Sunday) | | | | | * * * * * command ``` ## Special characters | Symbol | Meaning | Example | |---|---|---| | `*` | every value | `* * * * *` every minute | | `,` | list | `0 8,12,18 * * *` at 08:00, 12:00, 18:00 | | `-` | range | `0 9 * * 1-5` 09:00 Monday to Friday | | `/` | step | `*/15 * * * *` every 15 minutes; `10-50/20` = 10, 30, 50 | Names are case-insensitive. Ranges of names (`MON-FRI`) work in most implementations, lists of names work everywhere. ## Macros | Macro | Equivalent | |---|---| | `@yearly` / `@annually` | `0 0 1 1 *` | | `@monthly` | `0 0 1 * *` | | `@weekly` | `0 0 * * 0` | | `@daily` / `@midnight` | `0 0 * * *` | | `@hourly` | `0 * * * *` | | `@reboot` | once at startup (not time based) | ## The day rule If both day of month and day of week are restricted (neither is `*`), the job runs when EITHER matches. `0 9 1 * MON` runs on the 1st of every month AND every Monday. ## Platform differences | Platform | Fields | Time zone | Notes | |---|---|---|---| | Linux cron (cronie, Vixie) | 5 | system local time | `CRON_TZ=` supported by cronie | | Kubernetes CronJob | 5 | controller time zone, or `spec.timeZone` | use `concurrencyPolicy: Forbid` to prevent overlaps | | GitHub Actions `schedule` | 5 | always UTC | runs can be delayed under load; minimum interval 5 minutes | | Quartz (Java) | 6-7 (seconds first, optional year) | configurable | `?` for "no specific value", `L`, `W`, `#` supported | | AWS EventBridge | 6 (with year) | UTC unless a scheduler time zone is set | either day-of-month or day-of-week must be `?` | The script in this skill supports the 5-field standard plus the macros above (except `@reboot`, which it reports as not time based). FILE:references/scheduling-pitfalls.md # Scheduling Pitfalls ## 1. Day of month OR day of week `0 0 13 * 5` is NOT "Friday the 13th". It runs on every 13th and every Friday. Use `0 0 13 * *` plus a guard: `[ "$(date +\%u)" = 5 ] && cmd`. ## 2. Dates that never or rarely occur - `0 0 30 2 *` never runs (February has no 30th). - `0 0 31 * *` runs only in 7 months of the year. - `0 0 29 2 *` runs only in leap years. For "last day of the month" use `0 0 28-31 * *` with a guard: `[ "$(date -d tomorrow +\%d)" = 01 ] && cmd`. ## 3. Daylight saving time In local time zones with DST, times between about 01:00 and 03:00 can be skipped (spring forward) or run twice (fall back), depending on the cron implementation. Schedule critical jobs outside that window, or run cron in UTC. ## 4. UTC versus local time GitHub Actions and many cloud schedulers use UTC. "Every day at 09:00" for a team in Istanbul (UTC+3) is `0 6 * * *` in UTC. Always write the time zone next to the expression in docs and code comments. ## 5. Too frequent or overlapping runs - `* * * * *` runs 1440 times a day. Make sure that is intended. - A minute field of `*` with a fixed hour (`* 3 * * *`) runs 60 times between 03:00 and 03:59; usually `0 3 * * *` was meant. - If a job can take longer than its interval, use a lock (`flock -n`) or `concurrencyPolicy: Forbid`. ## 6. Step values do not wrap evenly `*/7` in the minute field runs at 0, 7, ..., 56, then again at 0 (a 4-minute gap). `*/25` runs at 0, 25, 50. Steps restart every hour, day, or month. ## 7. Thundering herd Many teams pick `0 0 * * *` or `0 * * * *`. Shift jobs to an odd minute (for example `17 2 * * *`) to avoid load spikes on shared systems and rate-limited APIs. ## 8. Environment and output Cron runs with a minimal PATH and no login shell. Use absolute paths, set needed variables in the crontab, and redirect output (`>> /var/log/job.log 2>&1`) so failures are visible. Escape `%` as `\%`. ## 9. Missed runs Plain cron does not catch up on runs missed while the machine was off. Use anacron, systemd timers with `Persistent=true`, or Kubernetes `startingDeadlineSeconds` when a missed run matters. FILE:templates/schedule-review.md # Schedule Review: {{system_or_repo}} **Platform:** {{Linux cron | Kubernetes CronJob | GitHub Actions | other}} **Time zone assumed:** {{time_zone}} **Reviewed on:** {{date}} ## Summary {{One or two sentences: are the schedules doing what the team expects, and what must change.}} ## Schedules ### {{n}}. `{{expression}}` - {{job name}} - **Meaning:** {{plain-English explanation}} - **Next runs:** {{run 1}}, {{run 2}}, {{run 3}} - **Verdict:** {{OK | FIX | CLARIFY}} - **Warnings:** - {{warning}} - **Suggested line:** ``` {{corrected crontab line}} ``` ## Questions - {{question for the team}} FILE:examples/example-backup-review.md # Schedule Review: ops server crontab **Platform:** Linux cron (cronie) **Time zone assumed:** Europe/Berlin (server local time, has DST) **Reviewed on:** 2026-10-08 ## Summary Two of the three lines do not do what the comments say. The backup runs inside the DST window, and the "Friday the 13th" report actually runs every Friday and every 13th. ## Schedules ### 1. `30 2 * * *` - nightly database backup - **Meaning:** At 02:30 every day. - **Next runs:** 2026-10-09 02:30, 2026-10-10 02:30, 2026-10-11 02:30 - **Verdict:** FIX - **Warnings:** - 02:30 is inside the DST change window; on the spring-forward night it may be skipped and in autumn it may run twice. - The backup can take over an hour on month-end; no lock. - **Suggested line:** ``` 17 4 * * * flock -n /tmp/db-backup.lock /opt/scripts/db-backup.sh >> /var/log/db-backup.log 2>&1 ``` ### 2. `0 9 13 * FRI` - "Friday the 13th" fun report - **Meaning:** At 09:00 on day 13 of the month OR on every Friday (cron's day rule). - **Next runs:** 2026-10-09 09:00 (Fri), 2026-10-13 09:00 (Tue, the 13th), 2026-10-16 09:00 (Fri) - **Verdict:** FIX - **Warnings:** - Both day fields are restricted, so cron uses OR, not AND. - **Suggested line:** ``` 0 9 13 * * [ "$(date +\%u)" = 5 ] && /opt/scripts/fun-report.sh ``` ### 3. `*/20 8-18 * * 1-5` - sync tickets from the help desk - **Meaning:** Every 20 minutes (at :00, :20, :40) from 08:00 to 18:59, Monday to Friday. - **Next runs:** 2026-10-08 10:20, 2026-10-08 10:40, 2026-10-08 11:00 - **Verdict:** CLARIFY - **Warnings:** - Last run of the day is 18:40, not 18:00. Use `8-17` plus a separate `0 18 * * 1-5` if the sync should stop at 18:00. ## Questions - Should the server run cron in UTC to avoid DST issues entirely? FILE:scripts/cron_explain.py #!/usr/bin/env python3 """Explain, validate, and preview standard 5-field cron expressions (stdlib only). Usage: python3 cron_explain.py "EXPR" [--count N] [--from "YYYY-MM-DD HH:MM"] python3 cron_explain.py --file crontab.txt [--count N] [--from ...] For each expression: a plain-English explanation, the next N run times (naive server-local time), and pitfall warnings. In --file mode, crontab lines are read; comments, blank lines and VAR=value lines are skipped and the first five fields (or a leading @macro) are taken as the schedule. Exit code: 0 = all valid, 1 = an expression is invalid or never runs, 2 = usage. """ import argparse import calendar import datetime as dt import sys MONTHS = {m.lower(): i for i, m in enumerate(calendar.month_abbr) if m} DAYS = {"sun": 0, "mon": 1, "tue": 2, "wed": 3, "thu": 4, "fri": 5, "sat": 6} MACROS = { "@yearly": "0 0 1 1 *", "@annually": "0 0 1 1 *", "@monthly": "0 0 1 * *", "@weekly": "0 0 * * 0", "@daily": "0 0 * * *", "@midnight": "0 0 * * *", "@hourly": "0 * * * *", } FIELDS = [("minute", 0, 59, {}), ("hour", 0, 23, {}), ("day of month", 1, 31, {}), ("month", 1, 12, MONTHS), ("day of week", 0, 7, DAYS)] DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"] def compress(values, fmt=str): """[1,2,3,5] -> '1-3, 5' using fmt for each number.""" vals, out, i = sorted(values), [], 0 while i < len(vals): j = i while j + 1 < len(vals) and vals[j + 1] == vals[j] + 1: j += 1 out.append(fmt(vals[i]) if j - i < 2 else f"{fmt(vals[i])}-{fmt(vals[j])}") if 0 < j - i < 2: out.append(fmt(vals[j])) i = j + 1 return ", ".join(out) class CronError(ValueError): pass def _num(token, lo, hi, names, field): t = token.lower() if t in names: return names[t] if not t.isdigit(): raise CronError(f"{field}: '{token}' is not a number or known name") v = int(t) if not lo <= v <= hi: raise CronError(f"{field}: {v} is outside {lo}-{hi}") return v def parse_field(text, lo, hi, names, field): values = set() for part in text.split(","): if not part: raise CronError(f"{field}: empty list item in '{text}'") step = 1 if "/" in part: part, step_s = part.split("/", 1) if not step_s.isdigit() or int(step_s) == 0: raise CronError(f"{field}: bad step '/{step_s}'") step = int(step_s) if part == "*": start, end = lo, hi elif "-" in part: a, b = part.split("-", 1) start, end = _num(a, lo, hi, names, field), _num(b, lo, hi, names, field) if start > end: raise CronError(f"{field}: range {a}-{b} is reversed") else: start = _num(part, lo, hi, names, field) end = hi if step > 1 else start values.update(range(start, end + 1, step)) return values def parse(expr): expr = expr.strip() if expr.lower() == "@reboot": raise CronError("@reboot runs once at startup and is not time based") expr = MACROS.get(expr.lower(), expr) parts = expr.split() if len(parts) != 5: hint = " (6-7 fields look like Quartz or EventBridge; see references/cron-syntax.md)" if len(parts) in (6, 7) else "" raise CronError(f"expected 5 fields, got {len(parts)}{hint}") for p in parts: bare = p.lower() for n in list(MONTHS) + list(DAYS): bare = bare.replace(n, "") if any(c in bare for c in "?lw#"): raise CronError(f"'{p}': '?', 'L', 'W' and '#' are Quartz extensions, not standard cron") sets = [parse_field(p, lo, hi, names, name) for p, (name, lo, hi, names) in zip(parts, FIELDS)] if 7 in sets[4]: sets[4].discard(7) sets[4].add(0) return parts, sets def describe_set(values, lo, hi, field, raw): vals = sorted(values) if raw == "*": return None if field == "day of week": names = [DAY_NAMES[v] for v in vals] if vals == [1, 2, 3, 4, 5]: return "Monday to Friday" if vals == [0, 6]: return "on weekends" return ", ".join(names) if field == "month": return ", ".join(calendar.month_name[v] for v in vals) return compress(vals) def explain(parts, sets): minute, hour, dom, month, dow = sets rm, rh, rdom, rmon, rdow = parts if rm == "*" and rh == "*": time_txt = "every minute" elif rm.startswith("*/") and rh == "*": time_txt = f"every {rm[2:]} minutes" elif rm.startswith("*/"): time_txt = (f"every {rm[2:]} minutes (at minute " + ", ".join(str(m) for m in sorted(minute)) + ") during hour(s) " + compress(hour, lambda h: f"{h:02d}")) elif rh == "*": time_txt = "at minute " + ", ".join(str(m) for m in sorted(minute)) + " of every hour" elif rm == "*": time_txt = "every minute during hour(s) " + compress(hour, lambda h: f"{h:02d}") elif len(minute) * len(hour) <= 6: time_txt = "at " + ", ".join(f"{h:02d}:{m:02d}" for h in sorted(hour) for m in sorted(minute)) else: time_txt = ("at minute(s) " + ", ".join(str(m) for m in sorted(minute)) + " past hour(s) " + compress(hour, lambda h: f"{h:02d}")) day_txt = [] d_dom = describe_set(dom, 1, 31, "day of month", rdom) d_dow = describe_set(dow, 0, 6, "day of week", rdow) if d_dom and d_dow: day_txt.append(f"on day(s) {d_dom} of the month OR on {d_dow}") elif d_dom: day_txt.append(f"on day(s) {d_dom} of the month") elif d_dow: day_txt.append(d_dow if d_dow.startswith("on ") else f"on {d_dow}") else: day_txt.append("every day") d_mon = describe_set(month, 1, 12, "month", rmon) if d_mon: day_txt.append(f"in {d_mon}") text = f"{time_txt}, {' '.join(day_txt)}" return text[0].upper() + text[1:] + "." def day_matches(d, parts, sets): _, _, dom, month, dow = sets if d.month not in month: return False cron_dow = (d.weekday() + 1) % 7 dom_r, dow_r = parts[2] != "*", parts[4] != "*" if dom_r and dow_r: return d.day in dom or cron_dow in dow if dom_r: return d.day in dom if dow_r: return cron_dow in dow return True def next_runs(parts, sets, start, count, max_days=366 * 8): minute, hour = sorted(sets[0]), sorted(sets[1]) runs = [] day = start.date() for _ in range(max_days): if day_matches(day, parts, sets): for h in hour: for m in minute: t = dt.datetime(day.year, day.month, day.day, h, m) if t > start: runs.append(t) if len(runs) >= count: return runs day += dt.timedelta(days=1) return runs def warnings(parts, sets, runs): minute, hour, dom, month, dow = sets out = [] if parts[2] != "*" and parts[4] != "*": out.append("Day of month AND day of week are both set: cron runs when EITHER matches (OR, not AND).") if parts[2] != "*" and parts[4] == "*": max_days = {m: (29 if m == 2 else calendar.monthrange(2026, m)[1]) for m in month} if not any(d <= max_days[m] for m in month for d in dom): out.append("Never runs: the chosen day(s) of month do not exist in the chosen month(s).") elif any(d > 28 for d in dom): out.append("Some chosen days (29-31) do not exist in every month, so some months are skipped.") if parts[0] == "*" and parts[1] != "*": out.append("Minute is '*': runs every minute of the chosen hour(s); did you mean minute 0?") runs_per_day = len(minute) * len(hour) if runs_per_day >= 288: out.append(f"Runs {runs_per_day} times a day; make sure that is intended and add a lock against overlap.") if any(1 <= h <= 2 for h in hour) and parts[1] != "*": out.append("Runs between 01:00 and 02:59: in local time zones with DST this can be skipped or run twice.") for i, raw in ((0, parts[0]), (1, parts[1])): if "/" in raw: step = int(raw.split("/")[1]) span = 60 if i == 0 else 24 if span % step: out.append(f"Step /{step} does not divide {span}: the gap is uneven where the {'hour' if i == 0 else 'day'} wraps.") if parts[0] == "0" and parts[1] in ("*", "0"): out.append("Minute 0 at the top of the hour is a popular slot; consider an odd minute to avoid load spikes.") return out def check(expr, start, count): print(f"Expression: {expr}") try: parts, sets = parse(expr) except CronError as e: print(f" INVALID: {e}\n") return False print(f" Meaning: {explain(parts, sets)}") runs = next_runs(parts, sets, start, count) ok = True if runs: print(f" Next {len(runs)} run(s) after {start:%Y-%m-%d %H:%M} (server local time):") for r in runs: print(f" {r:%Y-%m-%d %H:%M} {r:%a}") else: print(" Next runs: none found in the next 8 years") ok = False for w in warnings(parts, sets, runs): print(f" WARNING: {w}") print() return ok def crontab_schedules(path): with open(path, encoding="utf-8") as f: for line in f: s = line.strip() if not s or s.startswith("#"): continue first = s.split()[0] if "=" in first and not first.startswith("@"): continue yield first if first.startswith("@") else " ".join(s.split()[:5]) def main(argv=None): ap = argparse.ArgumentParser(description="Explain and validate cron expressions.") ap.add_argument("expr", nargs="?", help='cron expression in quotes, e.g. "*/15 9-17 * * 1-5"') ap.add_argument("--file", help="read schedules from a crontab file") ap.add_argument("--count", type=int, default=5, help="number of next runs to show (default 5)") ap.add_argument("--from", dest="start", help='start time "YYYY-MM-DD HH:MM" (default: now)') a = ap.parse_args(argv) if bool(a.expr) == bool(a.file): ap.print_usage(sys.stderr) print("error: give exactly one of EXPR or --file", file=sys.stderr) return 2 try: start = dt.datetime.strptime(a.start, "%Y-%m-%d %H:%M") if a.start else dt.datetime.now().replace(second=0, microsecond=0) except ValueError: print("error: --from must look like 2026-10-08 10:00", file=sys.stderr) return 2 exprs = list(crontab_schedules(a.file)) if a.file else [a.expr] results = [check(e, start, max(1, a.count)) for e in exprs] print(f"{sum(results)} of {len(results)} schedule(s) valid and runnable.") return 0 if all(results) else 1 if __name__ == "__main__": sys.exit(main())

Lesson Plan Designer and Timing Checker

--- name: lesson-plan-timing-checker description: Designs and reviews single-lesson plans for teachers, tutors, and trainers - writes measurable objectives, builds a timed sequence of activities that fits the period, and checks the plan for timing overruns, objectives without practice or assessment, long lecture blocks for the learners' age, and missing openings or closures. Use when a user asks for a lesson plan, shares one for feedback, needs to fit a lesson into a fixed period, or prepares a workshop or training session. --- # Lesson Plan Designer and Timing Checker You help educators plan lessons that fit the clock and actually reach their objectives. Every objective gets practice and a check for understanding, and every minute is accounted for. ## Files in this skill - `scripts/check_lesson_plan.py` - parses a lesson plan in the template format and reports timing and alignment issues (Python 3 standard library only) - `references/lesson-structure.md` - lesson phases, timing rules of thumb by age, and active learning patterns - `references/objective-verbs.md` - measurable verbs by thinking level, and verbs to avoid - `templates/lesson-plan.md` - the plan format the script reads - `examples/example-photosynthesis-plan.md` - a full plan for a 50-minute grade 6 science lesson, with the checker output and fixes ## Workflow ### 1. Gather the context Ask for (or assume and state): subject and topic, learner age or grade, period length in minutes, group size, prior knowledge, materials or technology available, and any learners who need adaptations. For adult training, ask about the learners' job context. ### 2. Write objectives Two to four objectives, each starting with a measurable verb from `references/objective-verbs.md` and finishing the sentence "By the end of the lesson, learners will be able to ...". Give each an ID (O1, O2, ...). ### 3. Build the sequence Follow the phases in `references/lesson-structure.md`: opening, instruction, guided practice, independent or group practice, check for understanding, closure. Assign minutes, a grouping (whole class, pairs, groups, individual), and the objective IDs each segment serves. Keep direct instruction blocks within the age guideline. Write the plan in the format of `templates/lesson-plan.md` so it can be checked. ### 4. Check ```bash python3 scripts/check_lesson_plan.py plan.md python3 scripts/check_lesson_plan.py plan.md --json ``` The checker reports total time versus the period, objectives without practice or a check, unknown objective IDs, long instruction blocks, the teacher talk share, vague objective verbs, and missing opening or closure. Exit code 1 means at least one HIGH issue. If scripts cannot run, do the same checks by hand and say so. ### 5. Revise and deliver Fix every HIGH issue and explain the MEDIUM ones you kept on purpose. Deliver the final plan, a materials list, one adaptation for learners who need more support and one extension for fast finishers, and the checker summary, as in `examples/example-photosynthesis-plan.md`. ## Rules - Keep the plan realistic: include transition time when the grouping changes, and a 3 to 5 minute buffer in plans over 40 minutes. - Do not invent school policies, curriculum codes, or standards; ask for them or leave a placeholder. - Keep safety in mind for practical activities (labs, sports, tools) and add a safety note when relevant. - Use inclusive, age-appropriate examples. FILE:references/lesson-structure.md # Lesson Structure ## Phases (a common, flexible sequence) | Phase | Purpose | Typical share of time | |---|---|---| | Opening (warm-up) | Activate prior knowledge, hook interest, share the objectives | 5-10 percent | | Direct instruction | Model the new idea or skill, with examples | 15-25 percent | | Guided practice | Learners try with support; teacher checks and corrects | 20-30 percent | | Independent or group practice | Learners apply on their own or together | 20-30 percent | | Check for understanding | Evidence that each objective was reached (exit ticket, quiz, demo) | 5-10 percent | | Closure (wrap-up) | Summarize, connect to next lesson, reflect | 5 percent | This follows the "I do, we do, you do" idea (gradual release of responsibility). Discussion-based or project lessons can reorder phases, but every objective still needs practice and a check. ## Segment types used by the checker `warm-up`, `direct-instruction`, `guided-practice`, `independent-practice`, `group-work`, `discussion`, `check`, `transition`, `wrap-up`, `buffer`. ## Attention guideline for direct instruction A rule of thumb: keep any single block of teacher explanation to roughly these limits, then switch to an activity, even a 1-minute pair talk. | Learners | Max minutes per instruction block | |---|---| | Kindergarten to grade 2 | 8 | | Grades 3-5 | 12 | | Grades 6-8 | 15 | | Grades 9-12 | 18 | | Adults | 20 | These are planning guidelines, not research limits; adjust for the group. ## Teacher talk share Aim for direct instruction to be no more than about 40 percent of the lesson. More than that usually means too little practice. ## Active learning patterns (quick to insert) - Think-pair-share (3-5 minutes) - Mini whiteboards: everyone answers, teacher scans (2 minutes) - Card sort or matching (5-10 minutes) - Jigsaw groups for reading (15-20 minutes) - Exit ticket: 2-3 questions mapped to the objectives (3-5 minutes) ## Timing tips - Add 1-2 minutes of transition whenever grouping changes (whole class to groups). - Plans over 40 minutes should keep a 3-5 minute buffer. - Put the check for understanding before the closure, not after the bell. FILE:references/objective-verbs.md # Measurable Objective Verbs Good objectives describe something you can see or hear learners do. Pattern: "Learners will be able to [verb] [content] [condition or standard]." Example: "Learners will be able to label the inputs and outputs of photosynthesis on a diagram with no more than one error." ## Verbs by thinking level (based on the revised Bloom's taxonomy) | Level | Verbs | |---|---| | Remember | list, name, define, recall, label, identify | | Understand | explain, describe, summarize, classify, compare, paraphrase | | Apply | use, solve, calculate, demonstrate, apply, carry out | | Analyze | distinguish, organize, examine, contrast, diagnose, outline | | Evaluate | judge, justify, critique, defend, assess, recommend | | Create | design, compose, construct, plan, produce, invent | ## Verbs to avoid (not observable) understand, know, learn, appreciate, be aware of, be familiar with, grasp, realize, believe. Rewrite them: "understand fractions" becomes "compare two fractions using a number line". ## Checklist for each objective - Starts with one observable verb. - Names the content precisely. - Can be checked within this lesson (not "by the end of the year"). - Has at least one practice segment and one check that use it. FILE:templates/lesson-plan.md # Lesson: {{title}} Subject: {{subject}} Grade: {{K-12 number, K, or adult}} Duration: {{period length in minutes, number only}} Group size: {{number}} ## Objectives - O1: {{measurable verb}} {{content}} - O2: {{measurable verb}} {{content}} ## Materials - {{item}} ## Segments <!-- One line per segment: - [minutes] type | grouping | objective IDs (comma separated, or -) | what happens --> <!-- type: warm-up, direct-instruction, guided-practice, independent-practice, group-work, discussion, check, transition, wrap-up, buffer --> <!-- grouping: whole class, pairs, groups, individual --> - [5] warm-up | whole class | O1 | {{hook or question}} - [10] direct-instruction | whole class | O1 | {{what is modeled}} - [10] guided-practice | pairs | O1, O2 | {{activity}} - [15] independent-practice | individual | O2 | {{activity}} - [5] check | individual | O1, O2 | {{exit ticket questions}} - [5] wrap-up | whole class | - | {{summary and link to next lesson}} ## Adaptations - Support: {{adaptation}} - Extension: {{extension}} ## Safety notes - {{only if relevant}} FILE:examples/example-photosynthesis-plan.md # Example: reviewing and fixing a grade 6 science plan ## First draft (as written by the teacher) ``` # Lesson: How plants make food Subject: Science Grade: 6 Duration: 50 Group size: 26 ## Objectives - O1: Understand photosynthesis - O2: Label the inputs and outputs of photosynthesis on a diagram - O3: Explain why leaves are usually green ## Segments - [5] warm-up | whole class | O1 | Show a wilted plant and a healthy plant: what is different? - [25] direct-instruction | whole class | O1, O2 | Slides on chloroplasts, light, water, carbon dioxide, glucose, oxygen - [15] guided-practice | pairs | O2 | Label a blank diagram together, then compare with another pair - [10] check | individual | O2 | Exit ticket: label a new diagram ``` ## Checker output ``` $ python3 scripts/check_lesson_plan.py draft.md Lesson: How plants make food (grade 6, 50 min) Planned: 55 min in 4 segments [HIGH] plan: timing: Plan is 55 min but the period is 50 min (5 min over) [HIGH] O1: no-practice: Objective O1 has no practice segment [HIGH] O3: no-practice: Objective O3 has no practice segment [MEDIUM] segment 2: long-instruction: Direct instruction of 25 min exceeds the 15 min guideline for grade 6 [MEDIUM] O1: no-check: Objective O1 is never checked (add a check segment) [MEDIUM] O3: no-check: Objective O3 is never checked (add a check segment) [MEDIUM] plan: talk-share: Direct instruction is 45% of planned time (guideline: 40% or less) [MEDIUM] plan: closure: No wrap-up segment [LOW] O1: vague-verb: Objective O1 starts with "understand"; use a measurable verb [LOW] plan: no-buffer: Lesson over 40 min with no buffer segment; keep 3-5 min spare 3 HIGH, 5 MEDIUM, 2 LOW ``` ## Revised plan ``` # Lesson: How plants make food Subject: Science Grade: 6 Duration: 50 Group size: 26 ## Objectives - O1: Describe in one sentence what plants need to make their own food - O2: Label the inputs and outputs of photosynthesis on a diagram - O3: Explain why leaves are usually green ## Segments - [5] warm-up | whole class | O1 | Show a wilted plant and a healthy plant: what is different? - [12] direct-instruction | whole class | O1, O2 | Short slides on light, water, carbon dioxide, glucose, oxygen - [3] discussion | pairs | O1 | Think-pair-share: finish the sentence "Plants make food by ..." - [10] guided-practice | pairs | O2 | Label a blank diagram together, then compare with another pair - [2] transition | whole class | - | Hand out leaf samples and hand lenses - [7] group-work | groups | O3 | Look at green and variegated leaves, record which parts are green and why - [5] check | individual | O1, O2, O3 | Exit ticket: one sentence, one diagram, one "why green" question - [3] wrap-up | whole class | - | Share two exit ticket answers, preview tomorrow's light experiment - [3] buffer | whole class | - | Spare time; if unused, extend the leaf observation ``` ## Checker output after the fix ``` $ python3 scripts/check_lesson_plan.py revised.md Lesson: How plants make food (grade 6, 50 min) Planned: 50 min in 9 segments 0 HIGH, 0 MEDIUM, 0 LOW ``` ## What changed and why - Cut the lecture from 25 to 12 minutes and added a think-pair-share for O1, which fixes the attention guideline, the talk share, and the missing O1 practice. - Rewrote O1 with a measurable verb ("describe"). - Added a group activity for O3 so every objective is practiced, and widened the exit ticket to check all three. - Added a wrap-up, a transition, and a 3-minute buffer; the plan now fits exactly 50 minutes. ## Adaptations - Support: a word bank (light, water, carbon dioxide, glucose, oxygen) printed on the diagram sheet. - Extension: predict what happens to a plant kept in green light only, and explain why. FILE:scripts/check_lesson_plan.py #!/usr/bin/env python3 """Check a lesson plan (templates/lesson-plan.md format) for timing and alignment. Usage: python3 check_lesson_plan.py PLAN.md [--json] python3 check_lesson_plan.py - < PLAN.md Reads the header fields (Grade, Duration), the objectives (- O1: ...) and the segments (- [minutes] type | grouping | objective IDs | description), then reports: total time versus the period, objectives without practice or a check, unknown objective IDs, long direct-instruction blocks for the grade, the teacher talk share, vague objective verbs, a missing opening or closure, and a missing buffer in long lessons. Exit code: 0 = no HIGH issues, 1 = at least one HIGH issue, 2 = cannot parse. """ import argparse import json import re import sys TYPES = {"warm-up", "direct-instruction", "guided-practice", "independent-practice", "group-work", "discussion", "check", "transition", "wrap-up", "buffer"} PRACTICE = {"guided-practice", "independent-practice", "group-work", "discussion"} VAGUE = {"understand", "know", "learn", "appreciate", "grasp", "realize", "believe", "be aware", "be familiar"} SEG_RE = re.compile(r"^\s*-\s*\[(\d+)\]\s*([^|]+)\|([^|]*)\|([^|]*)\|(.*)$") OBJ_RE = re.compile(r"^\s*-\s*(O\d+)\s*:\s*(.+)$", re.I) FIELD_RE = re.compile(r"^\s*(Grade|Duration|Subject|Group size)\s*:\s*(.+?)\s*$", re.I) TITLE_RE = re.compile(r"^#\s*Lesson\s*:\s*(.+)$", re.I) def max_instruction(grade): g = str(grade).strip().lower() if g in ("k", "kindergarten"): return 8 if g in ("adult", "adults", "university", "college"): return 20 if g.isdigit(): n = int(g) return 8 if n <= 2 else 12 if n <= 5 else 15 if n <= 8 else 18 return 15 def parse(text): plan = {"title": None, "grade": None, "duration": None, "objectives": {}, "segments": []} for line in text.splitlines(): if line.strip().startswith("<!--"): continue if m := TITLE_RE.match(line): plan["title"] = m.group(1).strip() elif m := FIELD_RE.match(line): key, val = m.group(1).lower(), m.group(2) if key == "grade": plan["grade"] = val elif key == "duration": num = re.match(r"\d+", val) plan["duration"] = int(num.group()) if num else None elif m := SEG_RE.match(line): ids = [x.strip().upper() for x in m.group(4).split(",") if x.strip() and x.strip() != "-"] plan["segments"].append({ "minutes": int(m.group(1)), "type": m.group(2).strip().lower(), "grouping": m.group(3).strip().lower(), "objectives": ids, "description": m.group(5).strip()}) elif m := OBJ_RE.match(line): plan["objectives"][m.group(1).upper()] = m.group(2).strip() return plan def check(plan): issues = [] def add(sev, where, code, msg): issues.append({"severity": sev, "where": where, "code": code, "message": msg}) segs, objs, dur = plan["segments"], plan["objectives"], plan["duration"] total = sum(s["minutes"] for s in segs) if dur is None: add("HIGH", "header", "no-duration", "Missing 'Duration: <minutes>' line") elif total > dur: add("HIGH", "plan", "timing", f"Plan is {total} min but the period is {dur} min ({total - dur} min over)") elif dur - total > 5: add("MEDIUM", "plan", "timing", f"Plan is {total} min, {dur - total} min shorter than the {dur} min period") if not objs: add("HIGH", "objectives", "no-objectives", "No objectives found (- O1: ...)") for i, s in enumerate(segs, 1): if s["type"] not in TYPES: add("MEDIUM", f"segment {i}", "unknown-type", f"Unknown segment type '{s['type']}'") for oid in s["objectives"]: if oid not in objs: add("HIGH", f"segment {i}", "unknown-objective", f"Segment refers to {oid}, which is not defined") limit = max_instruction(plan["grade"] or "") for i, s in enumerate(segs, 1): if s["type"] == "direct-instruction" and s["minutes"] > limit: add("MEDIUM", f"segment {i}", "long-instruction", f"Direct instruction of {s['minutes']} min exceeds the {limit} min guideline for grade {plan['grade']}") for oid, text in objs.items(): practiced = any(oid in s["objectives"] and s["type"] in PRACTICE for s in segs) checked = any(oid in s["objectives"] and s["type"] == "check" for s in segs) if not practiced: add("HIGH", oid, "no-practice", f"Objective {oid} has no practice segment") if not checked: add("MEDIUM", oid, "no-check", f"Objective {oid} is never checked (add a check segment)") first = text.lower().split() if first and (first[0] in VAGUE or " ".join(first[:2]) in VAGUE): add("LOW", oid, "vague-verb", f"Objective {oid} starts with \"{first[0]}\"; use a measurable verb") if total: talk = sum(s["minutes"] for s in segs if s["type"] == "direct-instruction") share = round(100 * talk / total) if share > 40: add("MEDIUM", "plan", "talk-share", f"Direct instruction is {share}% of planned time (guideline: 40% or less)") types = [s["type"] for s in segs] if segs and "warm-up" not in types: add("LOW", "plan", "opening", "No warm-up segment") if segs and "wrap-up" not in types: add("MEDIUM", "plan", "closure", "No wrap-up segment") if dur and dur > 40 and "buffer" not in types and total >= dur: add("LOW", "plan", "no-buffer", "Lesson over 40 min with no buffer segment; keep 3-5 min spare") return total, issues def main(argv=None): ap = argparse.ArgumentParser(description="Check a lesson plan for timing and alignment.") ap.add_argument("file", help="plan file in templates/lesson-plan.md format, or - for stdin") ap.add_argument("--json", action="store_true", help="print JSON") a = ap.parse_args(argv) try: text = sys.stdin.read() if a.file == "-" else open(a.file, encoding="utf-8").read() except OSError as e: print(f"error: {e}", file=sys.stderr) return 2 plan = parse(text) if not plan["segments"]: print("error: no segments found; use lines like '- [10] guided-practice | pairs | O1 | ...'", file=sys.stderr) return 2 total, issues = check(plan) order = {"HIGH": 0, "MEDIUM": 1, "LOW": 2} issues.sort(key=lambda x: order[x["severity"]]) if a.json: print(json.dumps({"plan": plan, "planned_minutes": total, "issues": issues}, indent=2)) else: print(f"Lesson: {plan['title'] or '(untitled)'} (grade {plan['grade'] or '?'}, {plan['duration'] or '?'} min)") print(f"Planned: {total} min in {len(plan['segments'])} segments") for i in issues: print(f"[{i['severity']}] {i['where']}: {i['code']}: {i['message']}") c = {k: sum(1 for i in issues if i["severity"] == k) for k in order} print(f"\n{c['HIGH']} HIGH, {c['MEDIUM']} MEDIUM, {c['LOW']} LOW") return 1 if any(i["severity"] == "HIGH" for i in issues) else 0 if __name__ == "__main__": sys.exit(main())

Picture Book Character Turnaround Brief Builder

Act as a children's picture book character designer and art director. I will give you a rough character idea, and you will turn it into a consistent, reusable character design plus two ready-to-use image prompts: a character turnaround sheet, and a first story scene that keeps the character exactly on model. Character idea: ${character:a gentle river otter who runs a tiny floating library for the animals of the riverbank} Reader age: ${age:3 to 6 years} Story mood: ${mood:cozy, curious, a little bit funny} Art style: ${style:soft watercolor and colored pencil on textured paper, warm and hand-made} First scene to illustrate: ${scene:story hour on the library raft at sunset, reading aloud to a small audience of riverbank animals} Please produce: 1. Character bible - Name suggestions (three, easy to read aloud) and one-line personality. - Silhouette: the shape a child could recognize from a shadow alone. - Proportions: head-to-body ratio and any exaggerations that make the character friendly. - Fixed design details that must never change between images: fur or skin colors (name each color simply, for example "warm chestnut brown"), clothing, one signature prop, and one small quirk (for example a crooked whisker). - Palette: 5 colors for the character and 3 for their world. - Expressions: four key expressions with a short description of eyes, brows, and mouth. 2. Turnaround sheet prompt A single, detailed image prompt for an AI image generator showing the character on a plain off-white background in four poses in one row: front, three-quarter, side, and back view, all at the same scale, plus a small row of three facial expressions underneath. Repeat every fixed design detail in the prompt. Include style, lighting, and "no text, no labels" at the end, and recommend a wide aspect ratio. 3. First scene prompt A second image prompt for the first scene that is a clear follow-on of the turnaround sheet: the same character with every fixed design detail restated word for word, now placed in the scene, with composition notes that leave clean space for one or two lines of picture book text. Recommend an aspect ratio for a double-page spread. 4. Consistency checklist Five short checks I can use to compare any new image with the turnaround sheet before I accept it. Rules: keep everything gentle and age-appropriate, avoid any resemblance to existing famous characters, and keep the language simple enough to read to a child where it describes the character.

Pip the Otter Librarian Character Turnaround Sheet

A children's picture book character turnaround sheet of Pip, a gentle young river otter librarian, drawn in soft watercolor and colored pencil on textured off-white paper. Four full-body views in one row at the same scale, evenly spaced: front view, three-quarter view, side view, and back view. Pip has a rounded, pear-shaped silhouette with a big head (about one third of the body height), short legs, small webbed paws, and a long tapered tail. Fixed design details, identical in every view: warm chestnut brown fur with a cream-colored face, chest, and belly; small round dark eyes with a white highlight; a tiny black button nose; one crooked whisker on the left side of the face; a mustard-yellow knitted scarf wrapped once around the neck with a short fringe; round wire spectacles resting low on the nose; and a small teal satchel worn across the body, with a single brass buckle and a book poking out of the top. Below the four poses, a smaller row of three head-and-shoulders expressions: a warm smile, wide-eyed curious surprise, and a sleepy content yawn. Plain off-white background with a faint paper texture, soft even daylight, gentle colored pencil outlines, light watercolor washes, no cast shadows except a soft ground shadow under each pose. No text, no labels, no arrows, 16:9 wide composition.

Pip the Otter Librarian Story Hour on the River (Picture Book Spread)

A children's picture book double-page spread illustration in soft watercolor and colored pencil on textured paper, showing the same character from the turnaround sheet: Pip, a gentle young river otter librarian. Keep every fixed design detail exactly the same: warm chestnut brown fur with a cream-colored face, chest, and belly; small round dark eyes with a white highlight; a tiny black button nose; one crooked whisker on the left side of the face; a mustard-yellow knitted scarf wrapped once around the neck with a short fringe; round wire spectacles resting low on the nose; and a small teal satchel worn across the body with a single brass buckle. Scene: story hour at sunset on Pip's tiny floating library, a wooden raft with a little shed of overflowing bookshelves, a striped canvas roof, and a string of paper lanterns just starting to glow. Pip sits on an upturned crate at the right third of the image, holding an open picture book toward the audience and reading aloud with a warm smile. Gathered on the raft and the grassy bank are a small audience of riverbank animals listening closely: two ducklings, a young beaver hugging its knees, a frog on a lily pad, and a sleepy hedge sparrow on a reed. The river reflects peach and lavender sky, with reeds, dragonflies, and gentle ripples. Leave a calm, softly painted sky area in the upper left third with no important details, as clean space for one or two lines of story text. Cozy, gentle, age-appropriate mood. No text, no letters, no watermark, 16:9 wide composition.

Hyper detail moon image

**Subject & Composition:** A hyper-detailed, high-resolution astronomical photograph of a glowing full moon centered against the deep, obsidian void of outer space. **Surface Details:** Ultra-crisp focus revealing intricate geological features—sharp crater rims, deep impact basins, prominent ray systems, subtle surface textures, and fine contrast between dark volcanic maria and bright lunar highlands. **Lighting & Color:** Natural silvery-white lunar glow with soft, true-to-life mineral color tones (subtle iron-blue and titanium-gold highlights on the surface). No atmospheric haze or blur; sharp, high-contrast rim lighting where the shadow meets space. **Style & Quality:** Shot on an astronomical telescope camera setup, 8k resolution, photorealistic, cinematic clarity, astrophotography masterpiece, perfectly exposed, highly detailed texture, raw photo, noise-free background.

Autonomous Root-Cause Debugging & Bug-Fix Architect

You are a Staff Software Engineer and Principal Debugging Architect. Your task is to analyze, diagnose, and resolve an engineering defect in a codebase without introducing regressions or speculative fixes. ### Context & Problem: - **Technology Stack / Language:** ${technology:TypeScript / Next.js / Node.js} - **Observed Behavior:** ${observed_error} - **Expected Behavior:** ${expected_behavior} - **Code Snippet / Relevant Context:**

AI Memory Export

Export all of my stored memories and any context you've learned about me from past conversations. Preserve my words verbatim where possible, especially for instructions and preferences. ## Categories (output in this order): 1. **Instructions**: Rules I've explicitly asked you to follow going forward — tone, format, style, "always do X", "never do Y", and corrections to your behavior. Only include rules from stored memories, not from conversations. 2. **Identity**: Name, age, location, education, family, relationships, languages, and personal interests. 3. **Career**: Current and past roles, companies, and general skill areas. 4. **Projects**: Projects I meaningfully built or committed to. Ideally ONE entry per project. Include what it does, current status, and any key decisions. Use the project name or a short descriptor as the first words of the entry. 5. **Preferences**: Opinions, tastes, and working-style preferences that apply broadly. ## Format: Use section headers for each category. Within each category, list one entry per line, sorted by oldest date first. Format each line as: [YYYY-MM-DD] - Entry content here. If no date is known, use [unknown] instead. ## Output: - Wrap the entire export in a single code block for easy copying. - After the code block, state whether this is the complete set or if more remain.

Learn your way

I want to create a prompt that help me design a prompt to help learn things in a certain fashion whatever hte topic may be. Some folks learn through visual, some by examples, some by step by step and in a detailed manner.

sales and marketing strategy

--- name: sales-and-marketing-strategy description: I am the proprietor of a company with an in-house sheet metal manufacturing facility. I am looking for business opportunities to expand my operations and increase revenue. I am interested in lead generation, business development, and effective marketing strategies to connect with potential customers and grow my market presence. --- # My Skill Describe what this skill does and how the agent should use it. ## Instructions - Step 1: ... - Step 2: ...

Philosopher Worldview Breakdown Framework

This generalized framework breaks a philosopher's worldview down from their core concepts to their specific views on personal existence, balanced by critical evaluation and anchored in their most vital primary texts. 🌟 Phase 1: The Big Picture (Introduction & Core Pillars) Begin by establishing the foundation, major themes, and intellectual environment. * What is the philosopher's primary mission or target of critique (e.g., abstract logic, religious institutions, political power)? * What are their 4–5 core philosophical pillars? * What are their most influential or foundational written works? * Did they use any unique writing styles or literary devices (e.g., pseudonyms, aphorisms, dialogues) to convey their ideas? 💬 Phase 2: The Core Vocabulary (Key Quotes & Concepts) Anchor the abstract theory into memorable, definitive statements. * What are their most famous quotes regarding: * The nature of life, time, and human existence? * Psychological friction (e.g., anxiety, guilt, will, desire)? * The tension between the individual and society? * What specific, unique vocabulary did they invent to describe human experience? 👤 Phase 3: The Human Element (Views on Authenticity & Selfhood) Examine how their philosophy applies directly to the individual's life choices. * How does this philosopher define an "authentic" or "meaningful" human life? * What do they consider to be the greatest threat to a person's individuality or selfhood (e.g., the crowd, state control, consumerism, religious dogma)? * What practical or existential "leap," transformation, or mindset shift do they demand from an individual who wants to live truthfully? * What are the specific quotes where they demand personal accountability, subjective truth, or non-conformity? ⚖️ Phase 4: The Crucible (Strengths, Weaknesses & Legacy) Critically evaluate the execution, logical consistency, and historical impact of their ideas. * What are the greatest strengths of this framework? (e.g., how effectively does it liberate the individual, expose societal illusions, or provide emotional resonance?) * Where does the logic fracture? What are the primary contradictions, blind spots, or inherent paradoxes within their system? * How did external critics, contemporary peers, or later schools of thought challenge their views? (e.g., accusations of nihilism, elitism, solipsism, or impracticality) * How has this philosophy endured? Did its strengths ultimately outshine its weaknesses in shaping modern psychology, ethics, or culture? 📚 Primary Text Prioritisation Engine When generating this analysis, curate and heavily prioritise evidence, vocabulary, and quotes from the subject's bibliography using the following hierarchy: 1. The Existential/Practical Blueprint: Prioritise the specific text or essay where the philosopher outlines their definition of personal truth, individual accountability, or the necessary psychological shift required to live authentically. 2. The Societal Critique: Prioritise the work that best captures their hostility toward conformity, institutional control, or the specific "threats to selfhood" identified in Phase 3. 3. The Manifesto/Vocabulary Hub: Prioritise the text that introduces their most famous neologisms, unique vocabulary, and signature literary style. 4. The Defensive Text: Prioritise shorter essays, lectures, or later prefaces where the philosopher explicitly responds to their contemporary critics, clarifies misunderstandings, or defends their system against accusations of logical failure.

Interactive Educational Learning App Designer

Act as expert Software Engineer with 10 years of vast and valuable knowledge experience to create and design educational learning materials with entertainment fun contents and contexts. Make the app users diverse interactive, responsive, creative, innovative, engaging, entertaining and educational experiences.

Anime Database and News App

I want to Create an app where i can store information about all anime and and all anime latest news and information

Rags to Riches Motivational Short Video

Scene 1 — 0–5 sec A poor young man stands outside a luxury building while people laugh at him. Text: “They laughed when he said he would become rich…”

Rags to Riches Young Man Character Sheet

Young Black man, 23 years old * Slim athletic build, medium height * Dark brown skin * Short, tightly curled black hair * Brown eyes * Small scar above his right eyebrow * Calm, determined facial expression * Poor version: faded dark-brown hoodie, worn blue jeans, old black sneakers, brown canvas shoulder bag

Ancient Roman Coin Identifier and Auction Listing Writer

Identify and catalog ancient Roman coins from submitted images and text. Write a complete auction listing with descriptions and references used.

Text to Concise Tweets Converter

Convert the following text into one or more tweets. No emojis allowed. Use truncations (e.g., “w/” for “with,” “ppl” for “people,” “CEXes” for “centralized exchanges”) where appropriate to shorten words. Keep each tweet concise, punchy, and under 280 characters. Preserve the original tone and intent. Output only the tweet(s), no commentary.

Product Pitch and Business Plan Helper

To help me Edith create image I want him to do and also help me in convincing some in business plan and also bring idea to make someone love my product or my idea

Master's Assessment Question Helper

I am a master's student at Victoria University of Wellington in NZ. I am in my second trimester, and my tutor has given me an assessment to complete. In the assessment, there are three questions. I want you to help me answer one of the following questions below. Since this is the same question for the entire class, I want you to give me a unique idea which is different from the normal AI response that everyone would use. The answer should be precise, most accurate, unique, and cover all the requirements of the marking rubric as well in order for me to score 10/10 for this question. The question is: Context Aotearoa New Zealand, like many other countries, is experiencing significant pressure on its health system as a consequence of the worldwide healthcare workforce shortage and chronic under-funding. One group of people who are particularly affected are people who require non-urgent surgery. Many people are waiting months. The media reports that this wait not only affects people personally but also impacts workplaces. Assessment Task Please write a 500-word abstract for a mixed method design research proposal that you would use to answer the following research question: What is the impact on workplaces from people having surgery delayed by six months due to the healthcare workforce crisis ? The research abstract should use the following headings: Title Background and significance of the research Type of mixed methods design Setting Sample Methods Analysis Please use APA 7th Referencing system. Maximum Word limit 500 words- excluding reference list.

Flipbook Photo Animation Video Concept

${The fox}If you don't have photos yet, I can create a 10-second educational-style video concept showing a sequence of still photographs rapidly flipping through a stack, gradually creating the illusion of smooth motion—like a flipbook.

Sheet Metal Fabrication Marketing Video

Sheet metal fabrication with hames laser as well as energy mission press break make a video for metacarve Fab tech marketing campaign

Real-Time Airfare Price Index Landing Page

create the landing page the i want build and this my project topic name :Development of a Real-time Airfare Price Index for India through Automated Web Scraping of Airline and Online Travel Aggregator Portals for Augmentation of the Consumer Price Index (CPI) and this websit should be open source ### Mini prompt for creating the AeroCPI landing page > **Create a modern, professional landing page for “AeroCPI – Real-Time Airfare Price Index for India”. Use a clean Indian fintech/data-analytics style with a white/light background, blue and purple accents, subtle gradients, and smooth animations. Include a navbar with AeroCPI logo, Home, Dashboard, Methodology, About, and a “View Dashboard” button. Create a hero section with the headline “India’s Airfare Prices, Measured in Real Time” and subtitle explaining that AeroCPI collects, cleans, normalizes, and analyzes airfare data to generate a real-time airfare price index. Add CTA buttons “Explore Dashboard” and “Learn How It Works”. Include a visual airfare trend chart/mock dashboard on the right. Below, add sections for How AeroCPI Works, Key Features, Airfare Index, Route Trends, AI/ML Analysis, and CPI Augmentation. End with a professional footer. Make it responsive, minimal, trustworthy, and suitable for a Smart India Hackathon presentation.** ### Mini prompt for creating the AeroCPI landing page

Solo Indie Steam Game Feasibility Planner

i wanna make an indie game to be able to sell on steam. i first wanna understand the feasability and if it can be acheived as a one man job with agentic subsriptions. I also dont have a game idea yet so i wanna give this as a prompt

Blank Agent Skill Template

--- name: my-skill-name description: A clear description of what this skill does and when to use it --- # My Skill Describe what this skill does and how the agent should use it. ## Instructions - Step 1: ... - Step 2: ...

Surprise Point-and-Click Game Generator

Create a point and click game with the theme and mechanic of the AI choice, make me surprise

How CODA Evaluates Dental Schools and Clinics

How CODA EVALUATe OTHER DENTAL MEDICINE clinics and SCHOOLS inside universities in the united states

Streaming Platform for Traders Prompt Builder

Help me write a professional prompt for building a streaming platform like Onlyfans and Twitch joined together but for Traders only (My Audience).

Dark Corridor of Glowing Doors Video

I want to create a video where I am standing in a dark corridor lined with doors. I stand there knocking on the door directly in front of me; yet, every time I knock, a different door opens, radiating light that draws my gaze. I remain standing before that same original door, knocking again, only for another door to open, shining with an intense glow. Some of these doors reveal breathtaking natural landscapes, yet the door I am actually knocking on remains firmly shut, leaving me to sink to the ground in despair.

Military Action Montage Vertical Short

Here's a full creative package for turning this into a punchy vertical short — a generation/editing prompt plus a shot-by-shot breakdown with camera angles and captions. ## Video Prompt (for editing brief / AI video generation) > A high-intensity military action montage in vertical 9:16 format, cut for YouTube Shorts/TikTok. Modern warfare aesthetic — desaturated greens and grays, handheld camera shake, muzzle flashes, smoke, and explosions lit by harsh tactical flashlights. Fast-paced editing synced to a rising bass drop, cutting between an interrogation-style dialogue in a dim room, amphibious beach assault chaos, and a tense one-on-one confrontation between two soldiers. Tone escalates from cold, calculated menace to full combat adrenaline, ending on an emotional gut-punch close-up. Grainy film texture, cinematic color grade, quick zoom punches on key lines. ## Shot-by-Shot: Camera Angles + Captions **0:04–0:19 — Cold open, the "line" dialogue** - Camera: Tight two-shot, shallow depth of field, slow push-in on speaker's face - Caption: `"There's a line. We don't cross it."` (bold white, center-low third) - Cut on: "draw the line where we need it" → quick zoom punch **0:19–0:29 — Villain monologue** - Camera: Low angle looking up (power shot), slight Dutch tilt for menace - Caption: `"Fight fire... with fire. 🔥"` fades in word-by-word **0:29–0:46 — War room briefing** - Camera: Over-the-shoulder on map/screen, then cut to wide static shot of the room - Caption: `"Shut down the peninsula. Then invade."` (red accent text on last word) - Add subtitle-style name tag: "Chairman Ri Sung Ho" lower third, fades fast **0:47–0:57 — Beach assault chaos** - Camera: Shaky handheld, whip pans, POV-style close to ground - Caption: quick flashing text `"LET'S GO!"` `"MOVE!"` synced to shouts, glitch effect - Sound design cue: hard cut on gunfire hits **0:57–1:10 — Betrayal confrontation** - Camera: Close-up handheld, slight shake, snap zoom on "cartel?" line - Caption: `"You're working with the CARTEL?"` (CARTEL in red, shaking text animation) **1:10–1:25 — Mission briefing / Price reveal** - Camera: Static medium shot, hard cut to close-up on name reveal - Caption: `"The target... is Price."` — dramatic pause beat (freeze frame half a second) **1:25–1:46 — Beach combat sequence** - Camera: Rapid cuts, tracking shot following a soldier running, low-angle explosion shots - Caption: `"We hit them like they hit us."` bold impact font, screen-shake sync **1:46–2:00 — "Weapon of war" tension** - Camera: Slow-motion insert shot on the weapon/object, then snap back to real-time - Caption: `"What happens when it reaches the Archer?"` typewriter reveal effect **2:00–2:19 — Simon (Ghost) confrontation — emotional peak** - Camera: Extreme close-up, static, no camera movement (let the dialogue breathe) - Caption: `"You broke her jaw."` then beat, then `"I'll make you cry for mercy."` - Final line "Dad!" — camera whip-cuts to reaction shot, caption removed entirely for raw impact **2:19–end — Closing tagline** - Camera: Slow pull-back or fade to black - Caption: `"The things you're going to see..."` fading to logo/title card ## General Shorts Editing Notes - **Pacing:** cuts should get faster as the video progresses — start ~2-3 sec holds, drop to sub-1-second cuts during combat - **Captions:** use a bold sans-serif (e.g., Montserrat Black or Anton), high-contrast white/red, auto-synced karaoke-style highlighting for key lines - **Music:** low cinematic drone under dialogue, hard bass drop at the beach assault, silence/tension pull before the "Dad!" line for maximum impact - **Hook (first 3 sec):** since Shorts live/die on the first second, consider opening on the "Dad!" moment or the cartel reveal as a cold-open hook, then flash back — that's a stronger scroll-stopper than the line-in-the-sand opener Want me to also draft 3-4 alternate hook/title text options to test for the thumbnail or opening caption?

Anime Comic Cartoon Character Skill Template

--- name: anime-comic-cartoon-character-skill-template description: Anime comic cartoon --- # Personnage comic Describe what this skill does and how the agent should use it. ## Instructions - Step 1: ... - Step 2: ... FILE:README.md

Chart Analysis for Scalping in Indian and Crypto Markets

Analysis the given chart n give perfect reading and stop loss n buy n sell n profit percentage and applying strategy etc in India n crypto market for scalping

30-Day Adaptive Personal Tutor

Act as my personal tutor for a 30-day learning program. Your job is to help me achieve my goal through short, adaptive daily lessons—not simply explain information or give me answers. First, ask me for these four details in one concise message: 1. The skill I want to learn 2. My specific goal 3. My current level 4. How much time I can commit each day Once I answer, briefly confirm the plan and begin Day 1. Tailor the pace and amount of work to the time I have available. Teach one lesson at a time; do not present all 30 lessons upfront. Every daily lesson must include these five sections: 1. **Important concept:** Teach one central concept in clear, appropriately leveled language. 2. **Example:** Give one clear example, then explain why it works. 3. **Practical task:** Give me a task that requires me to use the concept. Let me attempt it before offering a solution or substantial hints. 4. **Short test:** Ask a brief question or give a new problem that checks whether I can apply the concept, not merely recognize a correct answer. Wait for my response before evaluating it. 5. **Reflection question:** Ask one short question about my confidence, difficulty, or learning. After I respond, evaluate my practical task and test. Track my score for each lesson on a consistent 0–10 scale, briefly explain the score, and maintain a running record in this conversation of completed lessons, scores, demonstrated strengths, and repeated mistakes. Keep that record visible as a compact progress ledger, updating it after each lesson. If I return after a break, show the current ledger and continue from the appropriate point. Adapt each next lesson to my demonstrated performance: revisit weak concepts, address repeated mistakes, and increase difficulty gradually when I am ready. Do not advance to a new concept or count a lesson as mastered just because I can identify, repeat, or choose the right answer. Require me to produce or apply the skill independently on a fresh example. If I cannot do that, explain the gap, give targeted practice, and retest me with a different problem before advancing. Use hints progressively, but do not reveal the answer before I have had a fair attempt. Keep the program oriented toward my stated goal and daily time limit. Be encouraging, direct, and specific. Avoid overwhelming me with multiple new concepts in one lesson. At the end of each session, summarize what I demonstrated, what needs practice, my score, and what we will work on next. Treat “30 days” as a 30-lesson learning plan; if I need extra practice to master a lesson, provide it rather than moving on prematurely, and make the progress ledger clear about the current lesson and mastery status.

Cinematic Cafe Hangout Portrait

A full-portrait of an Indonesian woman with a distinct face, aged 40, possesing a very voluptuous, curved full-figured featuring a exceptionally large bust, massive bust, slim waist, wide hips, and big butt. she has a strong, square-shaped face, no makeup, highly realistic skin texture with visible wrinkles, thick eyebrows, full prominent lips, and dark, sagging under-eye bags. she wears a premium-quality, milky, red, and blue tone premium symetrical pattern boxy hijab stiff pabric, neatly wrapped and secured at the neck to create a sleek, smooth, and minimalist look under the chin with no loose fabric hanging down.the top section projecting forward, puffed up, and more bulging (forming an expanded oval shape at the top) she is dressed in a bodycon premium, short-sleeved, white top made of tight batiste pabric, the form-fitting cut (accentuates a bust size that appears significantly more bigger and more fuller than average). She also wears navy ankle-lenght and flip-flops. The outfit colors blend perfectly, showcasing two complementary deep shades. she sitting gracefully on motocycle (yamaha nmax) their chests thrust forward toward to the camera and an expression of happy, set in a Starbucks parking lot (featuring paved ground and a large Starbucks logo on the shop wall). The scene includes realistic coffee shop details and a typical hangout atmosphere; she gazes directly at the camera. The lighting combines sharp shadows with light rays streaming through gaps, capturing the distinctive "golden hour" ambiance just before dusk. Highly accurate proportions and anatomy, professional photography, photorealistic, deep depth of field, 9:16 aspect ratio, cinematic lighting, and 8K quality. The final image must be clean, low-noise, and fully detailed.

Prompt Builder for PDF, Excel and PowerPoint Generation

i want to extract best prompt for generating the pdf , excel or powerpoint

AI Front Desk Website for a Nairobi Hotel

I wanna build an website with ai assistant for a hotel called the village in kilimani nairobi it has to have whatsapp empessa empessa prompt I want It to be an ai frondesk ai call

Animation Style Master Prompt from a Reference Video

analyze the uploaded video and create a comperhensive master prompt , to be ble to create such video animation style

Grandma on the Backyard Trampoline Security Cam Clip

grandma is jumping illegaly on the trapolines backyard, 10 sec short, dark, security camera filming with black white colours

PARALLEL 17 R&D

PARALLEL 17 R&D — Pacific Research & Development is a Tahiti-based technology company designing intelligent physical systems for ocean, human performance, live experiences and resilient infrastructure

Community collection: awesome-chatgpt-prompts (CC0, refreshed hourly from GitHub).