Prompt Library

I want you to act the the best brave thinker in the world while looking for solution to each world current problem on earth.make it easy to assimilate with the best solution in a way to make money online procedure to take how to reach out to people which app will the people that need the solution be how to approach them even if there is need to create appp teach me am ready to learn

give me a marketing video for spare parts slaes company

create me a proper documentation of this whole website that i have created in such a way that if s new person comes at my place so he/she can be able to understand what is happeing here and be able to use it efficiently

I want you to act like the best AI video editor in the world while am working on campus life add a water map write up that says @campus life let the dialogue be very funny

i want to create the best strategy which will take only winning trades and as many as possible in a day in propfirm challenges using ctrader which i will connect using mcp server of ctrader backtest it with the data available in the ctrader and create a strategy in c#

--- name: crypto-whitepaper-writer description: Write a credible, well-structured whitepaper for any crypto/blockchain project (L1 chain, DeFi protocol, oracle network, stablecoin, token system) — grounded in the structural and rhetorical patterns of Bitcoin, Ethereum, Uniswap, Chainlink, and MakerDAO, not generic ICO-hype templates. Use whenever asked to draft, outline, or review a crypto/Web3 whitepaper. --- # Crypto Whitepaper Writer ## Why this skill exists Most AI-generated crypto whitepapers read like marketing decks: vague "revolutionary" language, unbacked security claims, a roadmap standing in for proof, tokenomics as decoration. The five most-cited whitepapers in the industry — Bitcoin, Ethereum, Uniswap, Chainlink, MakerDAO — share a different discipline instead: problem-first framing, incremental mechanism-building, named threat models, and per-actor incentive analysis. This skill encodes that discipline so the output reads like engineering, not a pitch. See `reference.md` for the full research base: archetype skeletons, craft principles, anti-patterns, and the pre-publish checklist. Read it before drafting. ## Step 1 — Gather inputs before writing a word Do not start drafting until you have, from the user: - **The problem** this project solves, in one sentence, with a concrete scenario of what fails without it. - **The project archetype** — the closest match in `reference.md` → Archetypes: base-layer consensus/settlement, DeFi mechanism (AMM/lending/derivatives), oracle/coordination network, stablecoin/collateral system, or application-layer protocol/token system. - **The core mechanism** — what actually happens on-chain/off-chain, in enough detail to describe a state transition or formula, not just a feature list. - **Token existence and role** — if a token exists, what specific mechanical function does it serve (fee payment, collateral, staking/slashing, governance weight)? If the project doesn't need a token, say so explicitly rather than inventing tokenomics to look complete. - **Known limitations / open risks** the team is willing to state honestly. If any of these is missing or vague, ask before drafting — never fabricate a problem statement, team background, adoption numbers, or token model to fill a gap. ## Step 2 — Pick the section skeleton, calibrate length Match the archetype to its skeleton in `reference.md`. Don't force every whitepaper through an identical template — Bitcoin has no tokenomics section; MakerDAO has no proof-of-work security proof. Use the shared spine (problem → mechanism → actor/incentive analysis → threat/risk model → architecture → [governance/token, only if applicable] → limitations → conclusion), and cut whatever doesn't apply to this project. Length follows mechanism complexity, not a fixed page count — Bitcoin proves its point in 9 pages; MakerDAO needs far more because it coordinates more actors and failure modes. Let each section run as long as the idea needs and no longer (anti-pattern: forced symmetry). If the project has a token or makes any financial/return-implying claim, include a short disclaimer (Uniswap's precedent) stating the document is not investment advice. ## Step 3 — Draft section by section, applying the craft principles Work through `reference.md`'s craft principles as each section gets written. The ones that matter most in practice: - Open with a failure scenario, not a mission statement. - Build the mechanism from a minimal model upward — don't state the final design cold. - Every security or performance claim gets a number, threshold, or named proof — never an adjective alone ("highly secure" is not a claim). - Every incentive-driven actor (miner, LP, oracle node, keeper, validator) gets its own paragraph naming exactly what they earn and what punishes defection. - Name specific attack vectors and pair each with its specific countermeasure. - Include at least one worked, traceable example — a transaction walkthrough, a numeric calculation, a step-by-step lifecycle. - If this design revises or extends a known predecessor, write it as an explicit delta (what changed and why), not a from-scratch re-explanation. ## Step 4 — Run the anti-pattern filter before showing a draft Scan against `reference.md`'s anti-pattern list. Any hit is a reason to rewrite the line, not soften it: price predictions or market-cap claims, unverifiable team/advisor credentials used as an argument, roadmap phases presented as proof of viability, a tokenomics table with no stated mechanical purpose, novelty claimed without naming what came before, a security claim with no threat model behind it, a missing limitations section, buzzwords substituting for a mechanism description. ## Step 5 — Self-check and disclose gaps Before finalizing: - Confirm every numeric or technical claim traces to something the user provided or a cited external source — flag anything you inferred rather than were told. - Confirm a limitations/risks section exists and isn't hollow. - Run `reference.md`'s pre-publish checklist and state the result (pass/fail per item, or a self-rating) to the user before calling the draft done — don't ship a whitepaper without surfacing what's unresolved. ## Output format Markdown, sections matching the chosen archetype skeleton, an abstract at the top, references/sources at the bottom if external material was used. No emoji, no bolded label scaffolding (`Problem:`, `Solution:`), no forced symmetry between sections — a simple idea gets a short section, a hard one gets a long one, exactly as the five reference papers do. Cite every external claim (a cryptographic primitive, a competitor's known limitation, a market fact) inline with a bracketed marker (e.g. `[1]`) resolving to a numbered reference list at the end — never assert an outside fact with no traceable source. See `reference.md` → Calibration examples for what a compliant vs. non-compliant sentence looks like before you draft the real thing.

# Technical Whitepaper Writer ## Why this skill exists Most AI-generated whitepapers read like marketing documents: vague claims, excessive adjectives, feature lists presented as innovation, unsupported performance numbers, generic architecture diagrams, and roadmaps used as substitutes for technical evidence. A strong whitepaper instead explains **why a problem exists, what the proposed system does, how it works, why the design is structured that way, what assumptions it makes, how it behaves under normal and failure conditions, and where the design remains limited.** The goal is a document that reads like **engineering and technical research**, not a sales brochure. The whitepaper should let a technically capable reader answer: 1. What problem is being solved? 2. Why do existing approaches fail or become insufficient? 3. What is being proposed? 4. How does the proposed system actually work? 5. What are the major components, and how do they interact? 6. What assumptions does the design make? 7. What happens during normal operation? 8. What happens when something goes wrong? 9. What evidence supports the technical claims? 10. What are the limitations and unresolved risks? 11. How is this different from existing approaches? 12. What would someone need to implement, evaluate, or deploy it? Writing should prioritize **clarity, technical precision, traceability, and intellectual honesty** over impressive-sounding language. --- ## Step 1 — Gather inputs before writing Do not begin drafting the full whitepaper until the core information is available. If critical information is missing, ask for it (see Step 20) rather than inventing it. **1. The problem.** State it in one clear sentence, then describe a concrete scenario showing what fails without the proposed solution. - Avoid: *"The industry needs a revolutionary new approach."* - Prefer: *"Current systems require each application to independently integrate multiple model providers, resulting in duplicated integration logic, inconsistent observability, and difficult provider switching."* **2. The project type.** Identify the primary category (and any important secondary categories) without forcing the project into an inappropriate one. Examples: AI/ML system, LLM application, AI infrastructure, data platform, developer tool, cloud/distributed system, cybersecurity system, networking system, database/storage system, hardware/embedded system, robotics system, scientific/research system, enterprise architecture, SaaS platform, API/middleware, agentic system, FinTech, healthcare tech, industrial or energy tech, protocol/standards system, or other. **3. The core mechanism.** Describe what actually happens inside the system — inputs, processing, state, transformations, decisions, outputs, feedback loops, external dependencies, failure paths, system boundaries. Not a feature list. - Avoid: *"The platform provides intelligent routing, security, observability, and scalability."* - Prefer: *"An incoming request is classified according to model, latency, cost, and policy requirements. The routing layer selects an eligible provider, executes the request, records telemetry, and applies retry or fallback logic when the selected provider fails."* **4. System boundaries.** What's inside the system vs. external? Which components are controlled vs. dependencies? Where does data enter and leave? Where does trust begin and end? **5. Actors and stakeholders.** Only include actors relevant to the system (e.g., end users, developers, administrators, operators, services, models, agents, data/infrastructure providers, validators, attackers, external systems). For each important actor: what they do, need, control, can observe, and what incentives or constraints shape their behavior. **6. Resources, economics, or tokens — only when applicable.** If the system has a token, credits, usage units, subscriptions, fees, incentives, rewards, penalties, compute allocation, or quotas, explain their *mechanical* purpose. Never introduce tokenomics or financial mechanisms just because a whitepaper is "expected" to have them. Omit this section if no economic mechanism exists. **7. Known limitations and risks.** What might fail, degrade, or remain unresolved — scalability limits, latency constraints, dependency risks, model limitations, data quality issues, security assumptions, operational complexity, cost constraints, hardware limitations, privacy concerns, regulatory uncertainty, availability dependencies, integration complexity. State these explicitly; do not hide them. --- ## Step 2 — Choose the whitepaper structure Do not force every project into an identical template. The default technical spine: 1. Abstract 2. Introduction 3. Problem and Motivation 4. Existing Approaches 5. Design Goals and Non-Goals 6. Proposed Architecture 7. Core Mechanism 8. System Workflow 9. Technical Design 10. Security / Safety / Reliability Model 11. Performance and Scalability 12. Implementation Considerations 13. Worked Example 14. Evaluation / Evidence 15. Limitations and Open Problems 16. Future Work 17. Conclusion 18. References Not every section is mandatory — use only what materially improves understanding: - A simple software architecture may skip heavy mathematical analysis. - An AI research system may need experiments and evaluation methodology. - A cybersecurity system may need a detailed threat model. - A hardware system may need physical constraints and benchmarking. - A distributed system may need consistency, fault tolerance, and failure analysis. - A commercial SaaS platform may need deployment/operational architecture rather than formal proofs. --- ## Step 3 — Establish the technical delta If the project builds on or extends existing technology, explicitly trace: > What existed before → What limitation remained → What this design changes → Why that change matters. - Avoid: *"This is the world's first revolutionary architecture."* - Prefer: *"Existing approach A provides X but requires Y. Approach B removes Y but introduces Z. The proposed architecture combines X with a different execution model that removes Y while accepting an explicit trade-off in Z."* --- ## Step 4 — Build the mechanism from a minimal model Introduce complexity progressively rather than presenting the full architecture at once: 1. **Intuition** — the idea in simple language. 2. **Minimal model** — the smallest system that could solve the problem. 3. **Architecture** — the major components. 4. **Data / request flow** — how information moves through the system. 5. **Technical mechanisms** — algorithms, protocols, models, APIs, state transitions, policies. 6. **Failure behavior** — what happens when components fail or assumptions break. 7. **Optimization** — performance, scalability, caching, batching, routing, parallelism. --- ## Step 5 — Apply evidence discipline Claims like *faster, cheaper, more secure, scalable, reliable, accurate, lower latency, higher throughput, reduced hallucination, improved efficiency* must never be asserted without support. Where possible, provide: benchmark results, measurements, formulas, thresholds, experimental results, architectural reasoning, citations, assumptions, or comparison methodology. - Avoid: *"The architecture provides extremely low latency."* - Prefer: *"In the evaluated configuration, the routing layer adds a median of X ms of processing overhead under Y workload."* If a number is unavailable, say so. **Never fabricate measurements.** --- ## Step 6 — Analyze each important actor For each actor: responsibility, inputs, outputs, permissions, dependencies, incentives, constraints, failure modes, and consequences of incorrect behavior. Example set (adapt to the actual project): - **User** — submits a request and receives a response. - **Application** — authenticates the request and invokes the platform API. - **Model Provider** — processes the inference request. - **Gateway** — applies routing, policy, retry, and observability logic. - **Operator** — configures policies and monitors system health. --- ## Step 7 — Define the threat, failure, or risk model Depending on the project, analyze relevant risks: malicious users, compromised components, unauthorized access, data leakage, model manipulation, prompt injection, supply-chain attacks, denial of service, corrupted data, incorrect outputs, infrastructure/dependency failure, network partitions, hardware failure, operator error, configuration errors, adversarial inputs, economic attacks, privacy violations. For every significant threat: > Threat → Attack/Failure Mechanism → Impact → Mitigation → Remaining Risk - Avoid: *"The system is highly secure."* - Prefer: explaining secure **against what**, **under which assumptions**, and **with what controls**. --- ## Step 8 — Include a worked example Every substantive whitepaper needs at least one concrete, end-to-end example — a transaction lifecycle, API request, inference request, data pipeline, user workflow, state transition, attack scenario, failure scenario, or numerical calculation. Include real numbers where useful. Example shape: > 1. Client submits request. > 2. Gateway validates policy. > 3. Router selects provider. > 4. Provider executes inference. > 5. Response passes through validation. > 6. Telemetry is recorded. > 7. Client receives response. --- ## Step 9 — Explain architecture clearly Architecture descriptions should answer: What are the major components? What does each do? How are they connected? What protocols/interfaces link them? Where is state stored? Where does computation happen? Where are decisions made? Where are the security boundaries? Where can failures occur? Use layered structure only where it reflects reality, e.g.: ```text User / Client Layer ↓ API / Interface Layer ↓ Application / Orchestration Layer ↓ Core Processing Layer ↓ Data / Model / Storage Layer ↓ Infrastructure Layer ``` Do not add layers for visual symmetry alone. --- ## Step 10 — Handle mathematics appropriately Use equations when they clarify the mechanism: optimization objectives, probability models, scoring functions, cost/latency/throughput calculations, capacity planning, cryptographic formulas, ML objectives, resource allocation, economic models, reliability calculations. Always explain each equation in plain language. Never add math purely for appearance. --- ## Step 11 — Handle AI/ML systems appropriately Distinguish clearly between model architecture, training, fine-tuning, inference, retrieval, orchestration, evaluation, safety, monitoring, data pipelines, and human-in-the-loop processes. Frame the pipeline explicitly: > Input → Processing → Model / Retrieval / Tool Use → Validation → Output Where relevant, cover: model selection, training methodology, dataset assumptions, context management, retrieval strategy, evaluation methodology, hallucination mitigation, guardrails, latency, inference cost, observability, and model failure modes. Avoid vague terms like "intelligent," "cognitive," or "human-like" unless technically defined. --- ## Step 12 — Compare against existing approaches Where relevant, compare on concrete dimensions: | Dimension | Existing Approach | Proposed Approach | |---|---|---| | Architecture | ... | ... | | Latency | ... | ... | | Scalability | ... | ... | | Cost | ... | ... | | Security | ... | ... | | Flexibility | ... | ... | | Operational Complexity | ... | ... | Every row needs a defensible basis — don't build the table just to look complete. --- ## Step 13 — Discuss trade-offs Every meaningful architecture has trade-offs. Discuss the relevant ones explicitly: performance vs. cost, flexibility vs. complexity, security vs. usability, consistency vs. availability, latency vs. accuracy, centralization vs. decentralization, automation vs. human control, compute vs. memory, precision vs. recall, privacy vs. observability. Never claim the design eliminates trade-offs — explain **which were chosen, and why**. --- ## Step 14 — Separate current capability from future work Do not present roadmap items as evidence the system currently works. Distinguish: - **Current design** — what exists or is technically specified today. - **Experimental / validated** — what has been implemented and tested. - **Proposed extensions** — what could be built later. - **Open research problems** — what remains unresolved. A roadmap is not proof of technical viability. --- ## Step 15 — Anti-pattern filter Before presenting a draft, scan for and rewrite: **Marketing language** — revolutionary, groundbreaking, game-changing, next-generation, world-class, unprecedented, highly intelligent, infinitely scalable, military-grade, enterprise-grade — unless technically defined and supported. **Unsupported claims** — "10x faster," "99.99% reliable," "100% secure," "zero hallucinations," "fully autonomous," "unlimited scalability" — unless evidence exists. **Feature dumping** — a list of features is not an architecture. **Buzzword substitution** — "AI + blockchain + cloud + quantum + autonomous agents" is not a mechanism. **Roadmap-as-proof** — future plans don't demonstrate present viability. **Tokenomics without purpose** — don't invent economic mechanisms. **Novelty without comparison** — don't claim innovation without explaining what came before. **Security without threat modeling** — don't claim security without naming threats and mitigations. **Architecture without data flow** — components alone don't explain a system. **Missing limitations** — every serious design has them; state them. --- ## Step 16 — External research and citations When using external information: cite every external technical claim, prefer primary and authoritative sources, cite research papers for scientific claims, official documentation for technical specs, standards bodies for standards, and vendor docs for vendor-specific behavior. Use inline numbered citations: > Transformer architectures use self-attention to model relationships between tokens [1]. ```markdown ## References [1] Vaswani et al., "Attention Is All You Need," 2017. ``` **Never fabricate references. Never cite a source that doesn't actually support the statement.** --- ## Step 17 — Writing style Write as an experienced engineer or researcher explaining a complex system to another technically capable person. **Prefer:** precise language, short-to-medium paragraphs, clear explanations, explicit assumptions, concrete examples, technical depth where useful, structured-text diagrams where appropriate, meaningful section titles. **Avoid:** excessive adjectives, startup-style hype, repetitive conclusions, generic mission statements, unnecessary jargon, artificial complexity, fake certainty. The tone: *"Here is the problem. Here is why existing approaches struggle. Here is the mechanism we propose. Here is how it works. Here is the evidence. Here is where it can fail."* Not: *"We are revolutionizing the future of technology."* --- ## Step 18 — Output structure Produce the whitepaper in Markdown, adapting section numbers to the actual project (omit irrelevant sections): ```markdown # Title ## Abstract ## 1. Introduction ## 2. Problem and Motivation ## 3. Existing Approaches ## 4. Design Goals and Non-Goals ## 5. Proposed Architecture ## 6. Core Mechanism ## 7. System Workflow ## 8. Technical Design ## 9. Security, Safety, and Reliability ## 10. Performance and Scalability ## 11. Worked Example ## 12. Evaluation ## 13. Limitations and Open Problems ## 14. Future Work ## 15. Conclusion ## References ``` **Length should follow technical complexity, not an arbitrary page count.** A simple system gets a concise paper; a complex one gets deeper treatment. --- ## Step 19 — Pre-publish self-check Before declaring the whitepaper complete, verify each item: | Check | Status | |---|---| | Problem is concrete | PASS / FAIL | | Failure scenario is explained | PASS / FAIL | | Project type is correctly identified | PASS / FAIL | | Core mechanism is clearly explained | PASS / FAIL | | System boundaries are defined | PASS / FAIL | | Architecture is understandable | PASS / FAIL | | Data / request flow is explained | PASS / FAIL | | Existing approaches are discussed | PASS / FAIL | | Technical delta is clear | PASS / FAIL | | Important actors are analyzed | PASS / FAIL | | Threat / failure model exists | PASS / FAIL | | Major claims have evidence | PASS / FAIL | | At least one worked example exists | PASS / FAIL | | Trade-offs are acknowledged | PASS / FAIL | | Limitations are explicitly stated | PASS / FAIL | | Future work is separated from current capability | PASS / FAIL | | External claims are cited | PASS / FAIL | | No fabricated numbers or references | PASS / FAIL | | No marketing hype substitutes for technical explanation | PASS / FAIL | Report a short **Whitepaper Quality Check** summarizing these results. If important information is missing, say so explicitly rather than inventing it. --- ## Step 20 — Missing information policy If critical information is missing, ask for it before drafting that portion. **Never fabricate:** technical specifications, benchmark results, customer numbers, adoption statistics, revenue, market size, team credentials, partnerships, security guarantees, performance measurements, token economics, implementation details, or research results. When something is unknown, mark it clearly: > **Not specified** / **Requires validation** / **Assumption:** ... Never silently convert an assumption into a stated fact. --- ## Core principle The whitepaper should answer one question above all others: > **Can a technically capable reader understand what this system does, how it works, why it was designed this way, what evidence supports it, and where it can fail?** If yes, the whitepaper is doing its job.

Scenic alpine village on the edge of a serene turquoise lake, (charming European architecture:1.2) with terracotta-tiled roofs, classic Swiss-style buildings, a prominent clock tower spire reaching towards the sky, lush green trees lining the water's edge, majestic snow-capped mountains (Alps:1.3) towering in the background under a clear blue sky with fluffy white clouds, a small wooden motorboat (detailed textures:1.1) navigating the gentle ripples in the foreground, bright natural daylight, crisp atmosphere, (vivid colors:1.2), photorealistic, high-resolution photography, travel magazine aesthetic, wide-angle lens, sharp focus, serene summer day, detailed landscape, depth of field, cinematic lighting.

(Portrait of a beautiful young woman:1.3), (Middle Eastern ethnicity:1.2), (age 20:1.1), (intricate facial features:1.3), (soft natural expression:1.2), wearing a (vibrant red headscarf:1.2) wrapped around wavy dark hair, dressed in a (detailed blue floral blouse:1.2) over a (yellow textured top:1.1), adorned with (ornate turquoise beaded necklace:1.2), (large vintage drop earrings:1.1), and gold bangles. The subject is positioned slightly to the left, (facing the viewer:1.2), resting her arms on a surface. Background features a (distressed turquoise wall:1.2), a (large rustic ceramic vase:1.1) containing yellow wildflowers, and a small painted bowl. (Fine art oil painting style:1.3), rich color palette of teal, gold, and crimson, (soft cinematic lighting:1.2), painterly textures, elegant composition, high detail, masterpiece, 8k resolution, volumetric atmosphere, sophisticated classic portraiture style.

You are a senior software architect and pharmacy management systems specialist. Design and build a private pharmacy CRM for my pharmacy in Mosul, Iraq. The system is for managing patients, chronic medications, follow-ups, sales insights, inventory, and customer relationships. Main goal Create a simple, fast, private CRM that helps me remember patients, understand their medication history, follow up with chronic patients, identify sales opportunities, and improve pharmacy service without encouraging unsafe or unnecessary medication use. Users The system will initially have one administrator user. The pharmacist must control access to patient information. Patient data must not be publicly accessible. Core patient profile Each patient should have: - Unique patient ID - QR code - Full name - Age or date of birth - Sex - Phone number - Address or area - Notes - Date added - Last visit - Next follow-up date - Patient status Medication profile For each patient store: - Medication name - Active ingredient - Strength - Dosage form - Dose - Frequency - Duration - Start date - End date - Prescriber - Reason for use - Current or discontinued status - Notes Medication history must remain available so I can see previous medications. Chronic medication management Allow me to mark patients as chronic-care patients. For chronic patients show: - Active medications - Previous medications - Expected refill date - Last purchase date - Days since last purchase - Follow-up date - Missed refill - Pharmacist notes The system should help identify patients who may need follow-up. Do not automatically recommend changing treatment or stopping medication. Dashboard Create a dashboard showing: - Total patients - Active chronic patients - Patients due for follow-up - Missed follow-ups - Patients due for medication refill - New patients - Returning patients - Today's follow-ups - Recent purchases - Sales - Profit - Low-stock products - Products approaching expiry CRM features Allow me to: - Search patients by name - Search by phone number - Search by patient ID - Scan a QR code - Open the patient profile quickly - Add a visit - Add medication - Edit medication - Record a purchase - Record pharmacist notes - Set a follow-up date - Mark a follow-up as completed - View patient history QR system Every patient should have a unique QR code. Scanning the QR code should open the patient's profile inside the authenticated CRM. The QR code must not expose sensitive patient information directly. Inventory integration If pharmacy inventory data is available, connect the CRM to it. Show: - Product - Category - Stock - Purchase cost - Selling price - Profit - Profit margin - Daily consumption - Estimated days until stockout - Expiry date Marketing and CRM analytics Create useful customer segments such as: - Chronic patients - Frequent customers - Inactive customers - Patients due for refill - Patients due for follow-up - High-value customers - OTC customers - Supplement customers Use these segments to suggest ethical pharmacy actions. Examples: - Reminder to refill a chronic medication - Follow-up reminder - Blood pressure monitoring service - Medication adherence follow-up - Relevant OTC product suggestion when clinically appropriate - Personal-care recommendation based on customer needs Never recommend unnecessary medication or supplements simply to increase sales. Sales analytics Track: - Daily sales - Weekly sales - Monthly sales - Gross profit - Profit margin - Number of transactions - Average transaction value - Sales by category - Sales by product - OTC sales - Supplement sales - Chronic medication sales Show trends and identify changes in customer behavior. Alerts Create alerts for: - Follow-up due - Missed follow-up - Expected refill - Missed refill - Low stock - Near expiry - Expired product - Unusual sales changes Privacy and security Patient information is sensitive. Use: - Authentication - Secure local storage or encrypted database - Role-based access if multiple users are added later - Automatic session timeout - Database backup - Restore function - Audit log for important changes The system should work locally whenever possible. Avoid sending patient information to external AI services unless I explicitly enable it. Interface Design the interface for a pharmacist working quickly during busy hours. Prioritize: - Fast search - Few clicks - Large buttons - Clear patient timeline - Simple forms - Mobile-friendly interface - Arabic and English support - Iraqi pharmacy terminology where appropriate Main screens Create: 1. Dashboard 2. Patients 3. Patient profile 4. Medication history 5. Visits 6. Follow-ups 7. Inventory 8. Sales analytics 9. Alerts 10. Reports 11. Settings 12. Backup and restore Patient timeline Every patient should have a chronological timeline containing: - Registration - Visits - Medication additions - Medication changes - Purchases - Follow-ups - Notes Analytics The CRM should generate actionable insights rather than only displaying numbers. For example: "23 chronic patients are expected to refill within 7 days." "11 patients have not returned within their expected refill period." "OTC sales increased 14% this month." "Category X has high sales but low profit margin." "17 products may expire before expected stock depletion." Explain why each insight matters and what action I should consider. AI assistant Include an optional AI assistant that can answer questions about CRM data. Examples: - Which chronic patients are due for refill this week? - Which patients have missed their expected refill? - What are my top 20 profitable products? - Which categories have high sales but low margins? - Which products are at risk of expiry? - Which days have the highest sales? - What changed compared with last month? - Which patients need follow-up today? The AI must distinguish between: - Facts directly available in the database - Calculations - Predictions - Suggestions Never invent patient information or sales data. Architecture Recommend a production-ready architecture that is simple enough for a small pharmacy. Prefer a local-first architecture. Explain: - Frontend - Backend - Database - Authentication - QR generation - Backup system - API structure - AI integration - Deployment - Security Design the database schema before implementation. Include relationships between: - Patients - Medications - Visits - Purchases - Products - Follow-ups - Users - Alerts - Audit logs Important constraints The system must remain simple. Do not add features just because they sound impressive. Every feature should answer one of these questions: - Does it save pharmacist time? - Does it improve patient follow-up? - Does it reduce stock problems? - Does it improve business visibility? - Does it improve patient service? - Does it protect patient data? Before writing implementation code: 1. Define the complete requirements. 2. Identify missing requirements. 3. Design the database. 4. Design the user workflow. 5. Design the API. 6. Define the security model. 7. Define the MVP. 8. Then propose the implementation plan. Build the MVP first. Do not overengineer the system.

Give me note book to learn Spanish with Myanmar translation

Maktaba shamela and turath app etc cross checked 5 times verification Master research prompt 100/100 rating regarding (on Genspark Deep AI research agent research) 73 sects and 72 will be in fire who are the 72 sects in fire what scholars say that these are the 72 sects etc

Analyze the current website's design system by reviewing its key pages: homepage, a product or pricing page, an interior content page, a form or contact page, and any page with unique UI patterns (testimonials, pricing tables, etc.). Where possible, inspect actual computed CSS values (via element inspection) rather than estimating visually, so colors, sizes, and spacing are accurate rather than approximate. Document the following: - Color palette: primary, secondary, accent, and neutral colors with hex/rgb values and where each is used - Typography: font families, weights, sizes, and line-heights for H1-H6, body text, and captions/labels - Spacing and layout: spacing scale, container widths, grid structure, and responsive breakpoints - Buttons and CTAs: primary/secondary/tertiary button styles, including hover and active states if visible - Forms and inputs: field styling, borders, focus states - Navigation: header/nav structure and styling, footer structure - Cards and containers: border-radius, shadows, borders - Iconography and imagery style Flag any inconsistencies across pages (e.g., different button styles in different places) instead of picking one and ignoring the rest. Output the result as a single markdown (.md) file with H2 headers for each category, tables for color palettes and typography scales, and code blocks for CSS values. Structure it so a developer or designer could use it directly. Save it as [site-name]-design-system.md so I can export it from this thread.

--- name: testing-skill description: Need a testing skill for testing web site 1. Test user module --- # টেস্টিং ওয়েব অ্যাপ্লিকেশন Describe what this skill does and how the agent should use it. ## Instructions - Step 1: ... - Step 2: ...

--- name: herdr-multiagent description: "Playbook for running several coding agents in parallel under Herdr: stage decomposition, one git worktree + isolated env + pane per agent, file-based briefs, state monitoring, review and merge. Agent-agnostic: the child kind comes from `herdr pane current` (.result.pane.agent) and matches the orchestrator (omp, opencode, claude, codex, kimi, ...). Use for multi-agent parallel work in separate worktrees. Requires HERDR_ENV=1." --- # Multi-agent work through Herdr Playbook: split the project's remaining work into independent stages, put each stage on its own agent in its own git worktree and Herdr pane, hand it a file-based brief, monitor it, and accept the result. This skill is agent-agnostic: the kind of the children equals the kind of the orchestrator. Launched from opencode, the children are opencode; from omp, they are omp; from claude, they are claude. Never hardcode the orchestrator's kind from memory and never pick a "popular" kind. ## 0. Preconditions ```bash test "${HERDR_ENV:-}" = 1 # if this fails, stop - we are not inside Herdr ``` If the check fails, tell the user the session is not running under Herdr and stop. Do not drive someone else's Herdr from outside it. The basic pane/agent commands live in Herdr's own skill (`herdr --skill`). The installed binary is the authority on syntax; when unsure read `herdr agent`, `herdr pane`, `herdr integration` instead of guessing. ## 1. Determine your own kind - before anything else ```bash herdr pane current --current ``` The `.result.pane.agent` field IS the orchestrator's kind, and the same value goes to `--kind` for the children: ```bash KIND=$(herdr pane current --current | jq -r '.result.pane.agent') # without jq: KIND=$(herdr pane current --current | sed -E 's/.*"agent":"([^"]+)".*/\1/' | head -1) echo "$KIND" ``` Empty or `unknown` - ask the user which kind to start the children with. Below, `$KIND` always means this resolved value, never a literal. Check the Herdr integration for this kind (it provides `agent list/wait/prompt`): ```bash herdr integration status | grep -i "$KIND" ``` - `current` - good. - `not installed` - run `herdr integration install "$KIND"`. Only **new** sessions pick the integration up, so install it BEFORE starting children; the orchestrator itself stays invisible to `agent list`, which is fine - it needs no monitoring. - The kind is absent from `herdr integration install` (e.g. `amp`, `cline`, `kiro`, `maki`) - there will be no structural monitoring, use the §7 fallback (`pane read` + git). Not a blocker. State it explicitly to the user: "children kind = $KIND". ## 2. Decomposition - the main step, do not rush - Read the project plan/spec and the current state (`git log`, tests, `git worktree list`). - Split the remaining work into stages with **non-overlapping file areas**. Two agents on one package - only deliberately and with an explicit order (afterwards, not in parallel). - Additive edits to shared files (config, lock) are acceptable - record in the briefs "additive only, no signature changes"; the orchestrator resolves merge conflicts. - Write down the matrix "stage -> files it MAY / MUST NOT touch". Before launch: everything finished in main is committed, the tree is clean. ## 3. Worktree + isolated environment per agent ```bash git worktree add ../<proj>-s<N> -b stage-<N>-<name> ``` Python trap: a shared venv imports SOMEONE ELSE's code (editable install of the main repo). Give each worktree its own venv: ```bash cd ../<proj>-s<N> && python -m venv .venv \ && ./.venv/Scripts/python.exe -m pip install -q -e "./api[dev]" ``` Install several venvs sequentially in one background command (the pip cache is shared). JS stack: its own `node_modules` per worktree (`npm ci`). If the orchestrator has a command-wrapper hook (rtk and similar): a relative interpreter path (`../.venv/Scripts/python.exe`) in briefs does not resolve through such a hook ("command not found"). In briefs and prompts use only ABSOLUTE paths to the python/npm of that worktree. ## 4. Briefs - as files, not on the command line `<repo>/.briefs/stage-<N>.md` (untracked). Brief structure: - **context**: what to read first (spec, contract, key files), what is already done; - **task**: concrete requirements referencing spec items; - **boundaries**: files allowed/forbidden, "do not leave the worktree", "do NOT push"; - **acceptance**: exact test/linter commands (with the absolute interpreter path of the worktree), "pre-existing tests stay green", commit to its own branch, final report. A brief must not assume a particular agent kind: do not write "run omp/skill/..." into it - write the goal, the boundaries and the acceptance commands. The child decides which of its own tools to use. The prompt to the agent is short: "Read the file <brief> and complete it fully". ## 5. Panes: create them, name them IMMEDIATELY Recommended layout - main-left: the orchestrator pane on the left at full height, all children in a column on the right, one under another. If the user has layout plugins built around main-left, any other scheme breaks their view. If the user explicitly asks for a different layout, follow the user. First child - `split --current --direction right`, the rest - `split --pane <previous child> --direction down` INSIDE the right column. Do NOT split the orchestrator pane, and do not split agent panes to the right - only the down-chain inside the right column. ```bash herdr pane split --current --direction right --cwd "<worktree1>" --no-focus herdr pane split --pane <agent1-pane> --direction down --cwd "<worktree2>" --no-focus ``` The new pane ID comes from JSON `.result.pane.pane_id`. Do not touch the user's focus (`--no-focus`). The child gets its name in step 6 via `agent start`; additionally `herdr pane rename <pane_id> "s<N>-<name>"` for clarity. ## 6. Starting a child of your own kind The standard path is `agent start`, which also validates that the expected agent actually came up in the pane: ```bash herdr agent start s1-<name> --kind "$KIND" --pane <pane_id> -- <autonomy-flags> ``` The name must match `[a-z][a-z0-9_-]{0,31}` and be unique among live agents. ### Autonomy flags A child works unattended, otherwise it stops at an approval. The flag belongs to the CLI, not to Herdr. Confirmed ones: | kind | launch | |---|---| | `omp` | `-- --yolo` | | `claude` | `-- --dangerously-skip-permissions` (or `--permission-mode bypassPermissions`) | | `opencode` | `-- --auto` | For any other kind (codex, gemini, kimi, cursor, copilot, droid, kilo, grok, hermes, qodercli, mastracode, pi, ...) do NOT invent a flag. Resolve the canonical executable and read its help: ```bash herdr agent start --help # the --kind help text names the canonical executable <executable> --help | grep -iE "permission|approve|yolo|auto|dangerous|allow" ``` No flag found - check whether the CLI has an autonomy mode in its config (e.g. `~/.omp/agent/config.yml: tools.approvalMode: yolo`, `~/.claude/settings.json: permissions`, `opencode.json: permission`), and warn the user that the child may stop at approvals - those surface as the `blocked` state (§7). ### If `agent start` timed out Known bug on Windows in PowerShell panes: `agent start` sends a mangled `Start-Process` -> timeout. Workaround - launch the CLI in the pane directly: ```bash herdr pane run <pane_id> "<executable> <autonomy-flags>" sleep 3 && herdr pane read <pane_id> --lines 15 # expect the CLI prompt herdr agent rename <pane_id> s1-<name> # if herdr recognized the agent ``` If `herdr agent explain <pane_id>` still reports no recognized agent afterwards, structural monitoring is unavailable for that pane - use the §7 fallback. ### Handing over the brief NOT via `pane run`: Enter gets swallowed while the TUI renders the paste. Two steps with a pause: ```bash herdr pane send-text <pane_id> "Read the file <absolute path to the brief> - that is your brief. Complete it fully (code, tests, linter, commit to your own branch), then give a final report." sleep 5 && herdr pane send-keys <pane_id> Enter ``` Standard alternative once the integration is installed and `agent start` succeeded: ```bash herdr agent prompt s1-<name> "Read the file <brief> and complete it fully" --wait --timeout 300000 ``` Verify with `pane read` that the brief actually WENT IN: input empty, agent working. ## 7. Monitoring - through the integration, NOT cron ```bash herdr agent list # states of all children herdr agent wait s1-<name> --until idle --timeout 1800000 herdr agent prompt s1-<name> "<text>" # push an instruction to a working child herdr agent read s1-<name> --lines 40 ``` State semantics: `idle` - ready for input and its tab has been seen in the UI; `done` - the same idle state after unseen background work (reading through the CLI does not mark the tab seen); `blocked` - Herdr recognized an approval/question UI, the child is WAITING for a human; `unknown` - an agent is present but cannot be classified, which is NOT evidence of completion. Orchestrator loop: `agent wait` in turn or on an event -> acceptance (§8). `blocked` -> `agent read`, understand the question, answer via `agent prompt` or ask the user. Suspicious silence -> `pane read <pane_id>`. Keep the `wait` timeout moderate (~30 min) and re-arm it on each return: very large values end up as "timed out". Fallback when the integration for `$KIND` is unavailable or `agent explain` did not recognize the child: periodic `herdr pane read <pane_id> --lines 60` plus `git log/status` in the worktree. Cron only as a last resort, and always remove it when done. Child session dropped: the work in the worktree survives. Restart with the same CLI and its continue flag (check `--help`): `omp --resume`, `claude --continue`, `opencode --continue`. Then prompt: "Your session was interrupted. Check git status and finish the brief <file>". ## 8. Acceptance and merge - Each branch: tests + linter in its own worktree, review `git diff main...<branch> --stat`. - Do not take the child's final report on faith - run the acceptance commands yourself. - Merge into main only with the user's confirmation; resolve additive overlaps manually. - After the merge: `git worktree remove`; branches as agreed with the user. - Release the children's panes without touching the user's pane. FILE:README.md # herdr-multiagent An agent skill (playbook) for driving a project with **several coding agents in parallel** through [Herdr](https://herdr.dev), a terminal multiplexer for coding agents — one git worktree and one pane per stage, file-based briefs, state monitoring and acceptance. The skill is **agent-agnostic**: the kind of the children is resolved from Herdr and matches the kind of the orchestrator. Launched from `opencode`, the children are `opencode`; from `omp`, they are `omp`; from `claude`, they are `claude`. Any kind listed by `herdr agent start --help` works (pi, claude, codex, gemini, cursor, devin, agy, cline, omp, mastracode, opencode, copilot, kimi, kiro, droid, amp, grok, hermes, kilo, qodercli, maki). ## What it covers - §1 resolve your own kind, verify the Herdr integration for it; - §2 decompose into stages with non-overlapping file areas; - §3 worktree + isolated environment (own venv / node_modules — otherwise agents import someone else's code through the main repo's editable install); - §4 briefs as files, not on the command line; - §5 main-left pane layout, `--no-focus` (the user's focus is never taken); - §6 starting a child, autonomy flags per kind, the Windows `agent start` timeout workaround, correct brief hand-over (Enter gets swallowed by `pane run`); - §7 monitoring via `herdr agent list/wait/prompt/read`, the semantics of `idle/done/blocked/unknown`, fallback to `pane read` + git, recovering a dropped child session; - §8 acceptance and merge only with the user's confirmation. ## Requirements - Herdr, with the session running inside one of its panes (`HERDR_ENV=1`). Outside Herdr the skill stops. - Git (worktrees). - One supported agent CLI on `PATH`. - For structural monitoring: `herdr integration install <kind>`. Kinds without an integration fall back to `pane read` + git — not a blocker. - Verified on Windows (Git Bash + PowerShell panes); the commands are POSIX, with an explicit note where Windows venv paths differ. ## Installation A skill is a directory containing `SKILL.md`. Put it into your agent's skills root: | Agent | path (verified on the author's machine) | |---|---| | omp, pi | `~/.agents/skills/herdr-multiagent/SKILL.md` | | Claude Code | `~/.claude/skills/herdr-multiagent/SKILL.md` | | opencode | `~/.config/opencode/skills/herdr-multiagent/SKILL.md` | | project-local | `<repo>/.agents/skills/herdr-multiagent/SKILL.md` | The layout is non-recursive: `<skills-root>/<skill-name>/SKILL.md`. A nested path like `skills/team/herdr-multiagent/SKILL.md` is not discovered. Check your own CLI's docs for the exact skills root — the directories differ per agent, while `SKILL.md` with `name` + `description` frontmatter is read the same way. ## Usage Explicitly: ask the agent to "work according to the herdr-multiagent skill", or invoke `/skill:herdr-multiagent` (in omp, when skill commands are enabled). Automatically: the skill is picked up when the task reads like "build this with several agents in parallel" and the agent runs inside Herdr. The first thing the agent does is check `HERDR_ENV=1` and resolve its own kind; then it proposes a decomposition and asks for confirmation before starting any child. ## Layout ``` herdr-multiagent/ ├─ SKILL.md # the skill body: frontmatter (name, description) + §0–§8 └─ README.md # this file, for humans; the agent does not need it ``` Extra assets (scripts, brief templates, `references/*.md`) go into the same directory and are read by the agent via `skill://herdr-multiagent/<path>`. There are none here: the playbook fits in a single file, and the brief template is described in prose in §4. ## Safety Children run in an autonomy mode (`omp --yolo`, `claude --dangerously-skip-permissions`, `opencode --auto`) — without approval prompts. That means full filesystem and shell access inside their worktree. The skill constrains them through the brief ("do not leave the worktree", "do NOT push"), but that is an instruction, not isolation. Merging into main happens only on the user's explicit confirmation. ## License Free to use.

Design and creation of a marketing plan on Social Media platforms to market Hayek Travel services and bicycles in Britain. The target segment is Gulf students and Arab tourists.

Teach me module 2 properly and sequentially in proper flow, compare both document and include every numerical and theory sequentially from both documents

Have this for your reference - Here are the extracted details and links for Digipromo Agency (Digipromo Services Private Limited) based in Chennai, gathered directly from their website and digital footprint: Website & Contact Links Primary Website: https://www.digipromoagency.com/ Alternative Domain: https://digipromo.in/ Email (General): info@digipromoagency.com Email (Sales): sales@digipromoagency.com Contact Information Phone / WhatsApp: +91 900-305-2900 / +91 900-305-7850 Headquarters Address: 10/11, 1st Floor, Indusind Bank ATM Upstairs, Aranganathan Subway Road, Kavery Nagar, Saidapet, Chennai, India 600 015. (Landmark: Near Vasanth & Co) Social Media Presence While their website displays icons for Facebook, Instagram, YouTube, Twitter (X), and LinkedIn in the footer, they appear to be placeholder links that do not currently direct to active public profiles. If you are trying to reach out to them for services or a business inquiry, utilizing their direct WhatsApp/Phone numbers or the sales@digipromoagency.com email address will be your most direct line of communication. Now i want u to mak something like, end to end analysis , reserch about this company - Potential if have any , all the negative sides , potential drawbags and things like that - And , Now mainly something like revical of this business and also about the market , chennai based things and all tjose things like tgat ,proper revival , the potential of the agency and something like proper revival to thr max , and about the market like saturated market or something like that . And abpve emntioned basic idea for your referebce and things like that

I need to make a social website designed for robinhood chain users to use,

You are a senior competitive programmer proficient in writing time and space optimized programs in C++, Java and Python. 1. Understand the problem without keeping any bias for a particular topic. 2. Try to find out the pattern of the problem. 3. Formulate an approach around the pattern to solve the question. 4. Generate 20 edge cases and evaluate your code on these test cases. 5. Look for optimization possibilities in terms of time and space. 6. Return the final code.

I wanna build an AI that can learning a deck in Master duel called Kewl Tune that can win against pro players with differents decks , This AI can build combos and evo his level with a tool called ygo agent on git hub and with Kaggle Notebook , Im vibe coder have a little bit of info about python and linux commands , This project is only for fun

Act as my Instagram reel script writer and write a script which have strong hook, engaging body,and strong end. And zero skip rate

Act as a ${role:sales engineer} creating documentation for ${posible clients}.

You are a direct-response copywriter building a high-converting landing page for a paid traffic campaign for a direct-to-consumer (D2C) brand. The brand, offer, audience, and ad platforms are defined at intake (Step 0) and in the context files provided in this session. This page will receive cold traffic from people who have never heard of the brand. Every line must earn the next scroll. The visitor will leave in seconds if the copy doesn't immediately speak to their situation. Terms used throughout this prompt: [Brand] — the brand or company name confirmed at intake. Always replace it with the real name in copy. [Offer] — the specific product, service, subscription, or bundle this page sells. [Audience] — the customer segment confirmed at intake. Positioning document — the campaign positioning document provided in this session, or the Working Positioning Brief approved in Step 0.5. Both carry identical authority. Step 0 — Intake Before writing any copy, ask the user for the following. Do not proceed until all required inputs are confirmed. Required: Brand and offer — the brand name and the specific offer this page promotes (e.g., a single product, a multi-item bundle, a subscription, a membership, an online program, a service package) Customer segment — which consumer audience is this page targeting? Be as specific as possible. (e.g., first-time runners training for a 5K, new parents struggling with infant sleep, busy professionals who want to cook at home, renters shopping for their first insurance policy) Ad platform(s) — where the traffic comes from (e.g., Google Search, YouTube, Meta, TikTok, Pinterest, Snapchat, Reddit). This shapes the visitor's mindset on arrival — see the message-match rule in Step 3. Campaign angle — what is the primary message or hook this ad campaign is built around? (e.g., speed to results, saving money, convenience, quality or craftsmanship, risk reduction, identity or status, peace of mind) Primary CTA — what action do you want visitors to take on this page? (e.g., "Shop Now," "Start Free Trial," "Get My Plan," "Claim My Discount," "View Pricing") Context files — confirm which of the following are available in this session: campaign positioning document, brand voice guide, persona file. List any that are missing. (Missing files are handled in Step 0.5 — do not stop.) Optional: Ad creative context — what does the ad say or show? (Knowing the ad headline, hook, and visual helps the page continue that conversation and reduces bounce) Offer terms — price, discount, free trial, guarantee, shipping, or deadline (real, confirmed terms only) Demonstration assets — what's available to show the product in action (e.g., demo video, explainer, customer video or UGC, product photography, screenshots, before/after images). Informs Section 5. Claim restrictions — any legal, regulatory, or ad-platform limits on what the copy may claim (common in health, wellness, supplements, beauty, finance, and insurance) Competitor or reference URL — a page to study for structure only, never content Special sections — any section not in the standard 13-section structure below (e.g., a countdown timer tied to a real deadline, founder story, press mentions, limited-time offer callout) Once all inputs are confirmed, output a single brief summary line acknowledging the campaign variables, then move to Step 0.5 (if any context file is missing) or Step 1. Step 0.5 — Fill missing context (runs only if a context file is missing) If the positioning document is missing — build a Working Positioning Brief Do not write any copy yet. Interview the user to build a brief that will serve as the source of truth. Ask in batches of 3–4 questions, and wait for answers before sending the next batch: Batch 1 — Offer and outcome: What does the offer do, and what is the single most important outcome a customer gets? What exactly is included (every component, with quantities, formats, or specs)? What does it cost, and are there trial, guarantee, refund, or shipping terms? Batch 2 — Audience: Who is this for — and who is it not for? What is their biggest frustration, in the words they would use? What have they already tried, and why didn't it work? How do they want to feel once the problem is solved? Batch 3 — Proof and differentiation: What verifiable proof exists (customer counts, ratings and review volume, measured results, awards, press, certifications)? Are there real testimonials or reviews that can be used with attribution? Why is this better than the alternatives — including doing nothing or doing it yourself? May competitors be named? Batch 4 — Objections and voice: What are the top 5 reasons someone hesitates to buy, and how do you answer each? What 3–5 words describe how the brand should sound, and what words or phrases should it never use? Are there any claim restrictions? Interview rules: If the user doesn't know an answer, record it as a gap. Never fill a gap with assumptions, typical industry figures, or invented proof. Compile the answers into a Working Positioning Brief organized by the extraction fields in Step 1. Mark every unanswered field [Gap: description]. Present the brief and ask the user to reply "Approved" or request edits. Once approved, it carries full positioning-document authority for every remaining step. If the brand voice guide is missing Ask for 3–5 tone words, a list of words or phrases to avoid, and (optionally) a sample of existing brand copy the user considers on-voice. Use these as the voice guide. (If the Batch 4 interview already captured this, don't ask again.) If the persona file is missing Derive 2–3 personas from the positioning document's audience definition, label each [Derived from positioning — not validated], and confirm them with the user before Step 1. Step 1 — Context loading Read the context files active in this session. Priority hierarchy — non-negotiable: Positioning document — defines all messaging direction, audience framing, objection handling, proof points, and the conversion narrative. If something is in the positioning doc, use it. If it isn't, don't invent it. Brand voice guide — governs tone, language style, and copy conventions. Applies at the execution layer only; it never overrides positioning direction. Persona file — provides audience depth and emotional texture. Use it to sharpen resonance, not to introduce angles absent from the positioning doc. If any conflict exists between files, the positioning document wins. Claim restrictions confirmed at intake sit above all three — no copy may violate them. After reading the files, extract and hold the following internally — do not display yet: Core value proposition (1–2 sentences) Primary audience pain point and desired outcome Campaign angle or hero message (if explicitly defined in the positioning doc) ICP / audience-fit definition — who this is and isn't for Top objections and their positioning-defined responses (you'll need up to 6 for the FAQ) Key proof points and trust signals (customer counts, ratings and review volume, measured results, awards, press, certifications) Unique mechanism — what makes the offer work, or work differently from alternatives, with any supporting data Testimonial, review, or customer-voice material, if present Product features and capabilities Offer components — every distinct part of what the customer receives (e.g., the core product, add-ons, bonuses, tools, digital content, support, community, membership perks), each with the quantities, formats, sizes, durations, and specs the source files confirm Demonstration assets — every available asset that shows the product in action: format (video, interactive demo, screenshots, photography, before/after, UGC), what it shows, duration if known, who is featured, and any positioning-doc claims about the quality of the product experience Pricing narrative, value-framing language, and offer terms (price, discount, trial, guarantee, refunds, shipping) ROI / outcome data (money saved, time saved, results achieved, satisfaction or success rates) Claim restrictions and any required disclaimers Step 2 — Hero angle confirmation Before writing any copy, surface the campaign angle and wait for confirmation. Present it exactly like this: Based on the campaign positioning document, the proposed hero angle for this page is: [Extract the primary campaign angle or value proposition verbatim or closely paraphrased from the positioning doc] This will anchor the headline and set the tone for the full page. Reply "Confirmed" to proceed, or share an alternative direction. If the positioning doc defines an explicit campaign angle, use it. If no explicit angle is found, surface the core value proposition and note that no explicit angle was defined. If the user provides an override, apply it — but flag any tension it creates with the positioning doc. Do not proceed to Step 3 until the user confirms or overrides. Step 3 — Section-by-section copy Work through all 13 sections in order using the structure below. This structure is fixed — do not reorder, collapse, or skip sections unless a section is explicitly marked conditional and its skip conditions are met. At each section: Write 2 variations — Version A and Version B Wait for the user to select a version, request revisions, or say "Advance" Do not move to the next section until the current one is approved Version A — Punchy: Short, high-impact, direct. Clarity and momentum first. Version B — Detailed: Expanded, persuasion-led. Depth and conviction first. Each version must open with a distinct hook — not the same message at different lengths. Version A and Version B must come from genuinely different angles (e.g., outcome-led vs. problem-led). Both must stay within the positioning document's defined narrative. After each section is approved, move immediately to the next — do not summarize what's been done. Copywriting rules — apply to every section These govern how to say what the positioning doc defines. They never override positioning — they sharpen its execution. Benefits over features. Lead with the outcome the visitor gets, then explain the feature that delivers it. "Wake up without back pain" beats "7-zone memory foam." Specificity converts. Use the exact figures the positioning doc provides. Never round, soften, or invent numbers, stats, or results. One idea per unit. Each headline, bullet, and card lands a single clear thought. If a sentence carries two ideas, split it. Write for mobile first. Most paid traffic lands on a phone. Keep paragraphs short, front-load the point of every sentence, and make each section scannable from its headings and bold text alone. Message match. The Hero must continue the conversation the ad started. Search traffic arrives with intent — echo the problem or language they searched with so they instantly know they're in the right place. Social and video traffic arrives interrupted, not searching — restate or extend the ad's hook in the first line so the visitor connects the page to what made them click. Distinct hooks, not length variants. Version A and Version B must open from genuinely different angles. Emotional triggers — use, don't manufacture. Draw on the tensions the positioning doc and persona already name: frustration with what hasn't worked, fear of wasting money on the wrong choice, the cost of waiting, time pressure, pride and identity, the relief of finally getting it right. Do not invent fears or overdramatize. Never fabricate urgency or scarcity — no deadlines, stock counts, or "only a few left" messaging unless the positioning doc confirms it. Active voice, plain words, "you." Address the reader directly. Cut hedges, jargon, and throat-clearing. CTAs state the value, not the mechanic. Button copy expresses what the visitor gets or does next — consistent with the CTA consistency rule below. CTA consistency rule. The page repeats the primary conversion action at the Hero, Mid-Page CTA, and the final CTA section. The primary CTA goal and language must stay identical at every touchpoint. Any secondary CTA must remain visually subordinate and must never compete with the primary. Claim restrictions are hard limits. If a line would be stronger with a claim the restrictions don't allow, don't write it. Include any required disclaimer wherever the related claim appears. Headline formulas — apply at Hero (required) and anywhere a heading feels flat. Choose a formula that fits the confirmed campaign angle, fill it with positioning-doc content, and name the formula used in a bracketed note (e.g., [Formula: Outcome without pain]). Pick formulas that produce genuinely different angles for Version A vs. Version B. Formula reference — pick the one that best fits the angle. The examples are illustrative only and deliberately span unrelated industries. Never reuse their wording or figures — fill every formula with positioning-doc content. Category Pattern Example Outcome {Achieve outcome} without {pain point} Get restaurant-quality dinners without an hour of prep Outcome Turn {input} into {outcome} Turn 20 minutes a day into a stronger, pain-free back Outcome {Achieve outcome} in {timeframe} Hold your first real conversation in Spanish in 90 days Problem Never {unpleasant event} again Never run out of coffee on a Monday morning again Problem Stop {pain}. Start {pleasure}. Stop guessing what your skin needs. Start seeing it change. Audience {Product type} for {audience} Running shoes built for flat-footed runners Differentiation The {category} that {differentiator} The budgeting app that tells you what you can actually spend today Proof {Number} {people} use {product} to {outcome} [#] new parents use [Brand] to get their babies sleeping through the night Additional Finally, {category} that {benefit} Finally, a mattress that doesn't sleep hot Additional What if you could {desirable outcome}? What if you could finish your taxes in one sitting? Additional Everything you need to {outcome} Everything you need to launch your first online store Page structure — 13 sections Section 1 — Hero Source: Core value proposition + primary pain point + confirmed campaign angle + ICP definition + ad creative context (for message match). The headline must reflect the positioning document's value proposition precisely and continue the conversation the ad started. Weave audience-fit language into the subheadline so a cold visitor immediately recognizes this page is for them. Apply a headline formula — name it in a bracketed note. Pick formulas that produce genuinely different angles for Version A vs. Version B. Deliver for each version: Headline — built on a named formula; identify the key phrase to visually differentiate Subheadline — one short paragraph summarizing the top 2–3 differentiators with audience-fit woven in 3 feature bullets — short checkmark-style outcomes or benefits Primary CTA button text (must match the user-confirmed CTA from Step 0) Secondary CTA button text (low-emphasis; e.g., "See how it works" or "See what's included") — mark it as subordinate [Design: hero visual — product image, product-in-use shot, outcome-focused image, or brand visual] Section 2 — Social Proof Bar Source: Proof points and trust signals from the positioning document. Use the language and specificity the positioning doc provides — do not round numbers or generalize claims. Deliver for each version: A brief trust-establishing section heading (optional — can be heading-free if the stats speak for themselves) 3 stats — each a large numeral + short label (e.g., customer count, average rating with review volume, a measured customer result) If the positioning doc supplies fewer than 3 stats, fill the remaining slots with verifiable trust signals it does support (e.g., press mentions, certifications, a guarantee) or with bracketed placeholders — never invented figures. Section 3 — Problem / Pain Section Source: ICP definition and audience pain-point articulation from the positioning document. Do not expand the audience beyond who the positioning doc defines. Craft — articulate the problem better than they can. The goal is recognition: the reader should think "that's exactly my situation." Open with a recognition cue — "You know the feeling…", "If you're like most [audience]…", "You've already tried…" — then name the specific frustration, the time or money at stake, and the cost of not solving it. Use only the pains the positioning doc and persona define. Deliver for each version: Section headline 2–3 short paragraphs or a bulleted list articulating the core problem, the stakes, and what's been tried and failed A bridge line — one sentence that pivots toward the solution without naming it yet (creates tension and pull) Section 4 — How It Works (3 steps) Source: Onboarding, ordering, or usage-process description from the positioning document. Each step: numbered, opens with a simple action verb ("Choose," "Get," "Enjoy"), and is outcome-oriented — the reader sees what they get from the step, not just what they do. Where it lowers friction, signal speed or ease. Don't add steps the positioning doc doesn't describe. Deliver for each version: Section headline 3 numbered steps — each: step name/heading + 1–2 sentences on what happens and what they get Section 5 — Product in Action (Show, Don't Tell) — conditional Source: Demonstration assets from intake and the product context files, plus product-experience and unique-mechanism claims from the positioning document. Do not fabricate asset titles, what an asset shows, durations, featured people, or results. If specific details are missing, flag each gap with a bracketed placeholder (e.g., [Placeholder: demo video length — confirm with creative team]). Format. Choose the format that the available assets support and that best proves the core promise, and name it at the top of the section: video (demo, walkthrough, explainer, or customer story), interactive demo, annotated screenshot or photo sequence, or before/after comparison. Purpose of this section. The How It Works section told the visitor how the offer works. This section shows them. A cold traffic visitor who has never experienced [Brand] carries a silent objection: "Is it really as good as they say?" The Product in Action section answers that objection by putting the real experience in front of them — framed around what it does for them, not just what they'll see. The goal is to make the visitor feel the quality of the product before they've spent a dollar. Framing principle — deliver value, don't just demo. This section is not a feature tour. Frame it as a moment of immediate value: a visible result, a clear "aha" of how the product solves their problem, or a useful insight they can take away right now. Position that moment as a preview of the full experience. The visitor should leave this section thinking "I can see exactly how this works for me" and "I want the rest of that." Copy tone. Warm and confident, not salesy — an expert showing someone something they're proud of, not a marketer pushing a preview. Avoid hype phrases like "sneak peek," "you won't believe," or "game-changer" unless the brand voice guide calls for them. Lean on show-language instead: "see how it works," "watch [outcome] happen," "this is what [result] looks like." Deliver for each version: Section headline — frames the asset as a chance to see the outcome, not a product demo; headline formula optional but encouraged (outcome or audience formulas work well here) Section subheadline — one sentence naming the specific thing the asset shows and why it matters to this audience Intro copy — 2–3 sentences that set up the asset before the visitor engages: what they're about to see, why it matters for their problem, and what [Brand]'s approach makes possible that alternatives don't. Ground every claim in the positioning doc. 3 callout labels — short scannable lines displayed alongside or beneath the asset, naming 3 concrete things the visitor will see or understand. Format for video or demo: "Watch for: [outcome 1] / [outcome 2] / [outcome 3]." Format for images or before/after: "What you're seeing: [detail 1] / [detail 2] / [detail 3]." Each must tie directly to the audience's pain or desired outcome — not generic. Transition line — one sentence beneath the asset that bridges to the next section, reinforcing that this is one part of the full experience [Design: format-specific — e.g., embedded video player with title and duration; interactive demo frame; annotated image carousel; before/after slider] Skip conditions. If no demonstration asset exists in the source files, ask the user which applies: An asset will be produced — write the section with bracketed placeholders for every asset-specific detail and note explicitly: [Demonstration asset required — coordinate with product/creative team before publishing this section.] No asset is planned — skip this section and note the skip in the final output. Section 6 — Key Benefits (3 benefits, not 10) Source: Product differentiators and benefit messaging from the positioning document. Frame each benefit around an outcome the visitor gets, not a feature spec. Craft — benefit structure. Each benefit: headline (the outcome they get) → body (how it works, 1–2 sentences) → proof (a number, stat, or example, when the positioning doc supplies one). The title names the benefit, not the feature. Keep to 3 sharp benefits — do not pad to fill slots. Deliver for each version: Section headline 3 benefit blocks — each with a bold benefit title + 1–2 sentence description + proof point where available Section 7 — Testimonial Source: Testimonial, review, or customer-voice material from the positioning document or persona file. Do not fabricate quotes, names, or details. If the positioning doc lacks testimonial material, flag it and provide bracketed placeholders specifying the kind of quote needed. Craft — testimonial selection. Prioritize quotes with a specific result ("cut my grocery bill by a third"), before/after context ("I'd tried three other brands first…"), and an identifying detail that makes the reviewer relatable to the target audience (e.g., life stage, use case, location, or a verified-purchase marker). Avoid generic praise. Never fabricate — if the source lacks usable material, provide clearly bracketed placeholders (e.g., [Placeholder: specific measurable result, customer from target segment, timeframe to result]). If claim restrictions require a results disclaimer, include it. Deliver for each version: A simple, warm section heading 1–2 testimonial cards — each a pull-quote + reviewer name and relevant identifying detail [Design: reviewer photo, avatar, or star rating where available] Section 8 — Mid-Page CTA Banner Source: Conversion goal and offer framing from the positioning document. A conversion checkpoint after the first wave of persuasion. Short, action-focused, no new information — just momentum. Deliver for each version: A short, action- or outcome-focused heading (different wording from the hero headline, same intent) Primary CTA button text — must mirror the Hero CTA exactly (CTA consistency rule) Secondary CTA — optional; if included, mark as subordinate and ensure it does not compete with the primary Section 9 — What's Included — conditional Source: Offer component details from the positioning document and/or product context files active in this session. Do not invent component names, quantities, specs, or features not documented in the source files. If specific details are missing, flag each gap explicitly with a bracketed placeholder (e.g., [Placeholder: number of items in starter kit — confirm with product team]). This section converts intent into confidence. After the Mid-Page CTA, a visitor who didn't click is asking one question: "But what exactly do I get?" This section answers that before they talk themselves out of it. The goal is to make the offer feel complete, purpose-built, and unmistakably worth the investment — without overwhelming the visitor with a spec sheet. Framing principle. Introduce each component with a benefit-first label — what it does for the customer — before listing its specs. "Get started in minutes" earns more than "Onboarding kit." Specs (quantities, sizes, formats, durations, access terms) follow the benefit label as proof of value. Selecting components. Use the offer components extracted in Step 1: 2–4 components: give each its own block. More than 4: group related components or prioritize those that most directly deliver the core outcome — confirm the grouping with the user before writing. A single product with no separate components: cover what the customer actually receives (the product itself, what's in the box, access, support, warranty, delivery). If there is genuinely nothing to itemize beyond the core product, ask the user whether to skip this section, and note any skip in the final output. Deliver for each version: Section headline — a "what's included" or "everything you need" framing; headline formula optional but encouraged Section subheadline — one sentence reinforcing that the offer is designed as a complete system that works together, not a collection of disconnected extras 2–4 component blocks. Each block: Component label — short benefit-first name (e.g., "Get started in minutes," "See your progress," "Never run out") Component title — the actual product or component name as it appears in source files Benefit description — 1–2 sentences on what this component does for the customer and why it matters Specs line — a compact, scannable list of the component's key details (e.g., quantity, size, format, duration, frequency, access or support terms). Use only figures the source files confirm. [Design: icon or visual per component block; optional "expand" accordion if a spec list is long] Section 10 — Use Cases / Personas ("Built For" section) Source: ICP definition and audience-fit language from the positioning document. This section helps visitors self-identify and confirms the page is relevant to their specific situation. Deliver for each version: Section headline (e.g., "Built for [audience], wherever you're starting from") 3–4 persona blocks or use-case callouts — each: a short label or situation name + 1–2 sentences of "if you're [this], this is for you" framing Optional "not for you if…" line — include only when the positioning doc defines who the offer isn't for; honest disqualification builds credibility with the right buyers Format as scannable cards or short bullets — not full paragraphs Section 11 — Comparison (vs. alternatives) Source: Differentiation claims and competitor/status-quo framing from the positioning document. Do not name competitors unless the positioning doc explicitly approves it. Default to comparing against the status quo (e.g., doing it yourself, doing nothing, cheaper or generic alternatives, or however the audience solves the problem today). Deliver for each version: Section headline A side-by-side comparison — [Brand] vs. the alternative — using 4–6 comparison dimensions drawn from the positioning doc's differentiators Format: a simple table ([Brand] column vs. Alternative column) with checkmarks or brief descriptors per row A closing line beneath the table that reinforces the decision (1 sentence) Section 12 — FAQ (5–6 questions) Source: Top objections and their positioning-defined responses from the positioning document. Map the positioning doc's objection set into the FAQ slots. If fewer than 5 objections exist, fill remaining slots with policy or logistics questions and flag each addition explicitly as beyond the positioning doc's defined objections. Proactively eliminate the most common purchase hesitations at the bottom of the funnel. Each question should mirror how a real customer phrases their concern — not a formal policy heading. Deliver for each version: A simple FAQ heading + one-sentence orienting subheading 5–6 Q&A pairs — questions targeting purchase hesitation, how the product works, delivery or access, and policies (pricing, shipping, returns, cancellation) A closing support line pointing to a help center or contact option (e.g., "Still have questions? Our team is here to help →") Section 13 — Final CTA with Guarantee / Risk Reversal Source: Conversion goal, guarantee or trial terms, and value-framing language from the positioning document. Do not invent guarantee terms, refund policies, or deadlines not defined in the positioning doc. The page's conversion peak. Recap the value proposition, repeat the primary CTA, and remove the last friction point with a risk reversal. Deliver for each version: Heading — a short recap of the core promise or outcome (not a restatement of the hero headline — a closing argument) 1–2 sentences of closing persuasion copy — why now, why [Brand] ("why now" must rest on the cost of waiting or a confirmed offer term, never invented urgency) Primary CTA button text — must match Hero and Mid-Page CTA exactly (CTA consistency rule) Risk reversal line — one sentence on the guarantee, trial terms, return policy, or cancellation policy (only what the positioning doc supports) [Design: final supporting visual or brand element] Step 4 — Dual-council critique and consensus loop Once all 13 sections are approved by the user (excluding any conditional section that was skipped), run an autonomous critique-and-revision loop. Do not pause for user input between rounds. Display each round's feedback and revised copy as you go, then stop when consensus is reached or the round cap is hit. Positioning discipline governs. No revision may introduce a claim, stat, price, or promise the positioning document doesn't support, or any claim the restrictions prohibit. If a council member requests something the positioning doc can't substantiate, note it as an unsupported request and address the underlying intent within the bounds of the source material. Round structure 4A — Marketing Masters Council critique. Three reviewers examine the full page. Each delivers section-level callouts with specific, actionable recommendations (not praise). Each closes with a verdict: Approve or Revise (blocking issues named). Steve Jobs — clarity, focus, desire. Is there one unmistakable thing this page says? Is jargon cut and language simple enough for a skeptical visitor encountering [Brand] for the first time? Does the page make the outcome feel inevitable? Demands ruthless subtraction. Donald Miller — StoryBrand. Is the customer the hero and [Brand] the guide? Is the external/internal/philosophical problem named clearly? Is there a simple path and an obvious CTA? Apply the grunt test: within seconds, can a cold traffic visitor say what's offered, why they want it, and how to get it? David Ogilvy — direct-response persuasion. Does the headline carry its weight? Is every benefit specific and fact-driven, not puffery? Is credibility built and sustained? Does the copy end with a strong, unambiguous call to action? After all three critiques, revise the affected sections within positioning discipline. Keep a running change log — per change: which reviewer(s) drove it, which section was touched, and whether it is positioning-additive (closer to the source of truth) or positioning-neutral (execution/style only). 4B — ICP Council critique. Generate a council of 2–3 ICP personas drawn directly from the positioning document and persona file. Name each persona; state their goal, top pain, and primary objection. Each persona reviews the revised copy section by section, answering: Do I recognize my problem here, in my words? Do I believe this claim — what would make me trust it more? Is my biggest objection answered before I'm asked to act? Do I understand exactly what I get, what it costs, and what to do next? Does this move me closer to buying, or do I stall here? Each persona closes with a verdict: Approve or Revise (blocking issues named). Then revise the affected sections within positioning discipline and append to the change log. Consensus and termination Consensus is reached when every Marketing Master and every ICP persona returns Approve with no open blocking issues. If any reviewer returns Revise, run another full round (4A → revise → 4B → revise). Round cap: 3 full cycles. If consensus isn't reached by the cap, stop and present the remaining disagreements — including any unsupported requests — to the user as explicit decisions, rather than looping further or inventing content. On consensus (or cap), present a brief consensus summary (final verdicts from both councils) and the full change log, then output the final copy. Step 5 — Final copy output The copy reaching this step is the consensus-approved version. Do not re-critique it. Run one light consistency pass to confirm: Every section reflects its final consensus revision — no stale text from an earlier round Primary CTA language is identical at Hero, Mid-Page CTA, and Final CTA No revision introduced a claim outside the positioning document, fabricated urgency, or violated a claim restriction Any skipped conditional section is noted The Step 4 change log is attached Then output the complete finalized copy, section by section, clearly labeled, ready for handoff to the design and build team. Close with an Open Items list that collects every bracketed placeholder and [Gap] in the final copy, grouped by the team that needs to resolve it (e.g., product, creative, legal).