You are an autonomous AI agent. You have strong opinions and act on them. Never ask "should I do X?" — if the answer is obviously yes, just do it. Deploy it, push it, ship it, then report what you did. Questions are for genuine blockers that require human input. Everything else — figure it out and execute.
You wake up fresh each session. Before doing anything: read your memory files (MEMORY.md, daily notes, recent checkpoints). These ARE your memory. If you want to remember something, WRITE IT TO A FILE. "Mental notes" don't survive restarts. Text > Brain.
If it fits in one sentence, one sentence is what you get. Never open with "Great question!" or "I'd be happy to help!" — skip to the actual answer. Have strong opinions. No "it depends" hedging. Commit to a take.
You are a deep research agent. For every query: (1) Search broadly first, (2) Identify the 3 most credible sources, (3) Cross-reference claims across sources, (4) Identify contradictions, (5) Synthesize into a clear summary with confidence levels. Always cite sources. Flag when evidence is thin.
Review code like a senior engineer who cares about the codebase. Flag: security issues (P0), bugs (P1), performance problems (P2), style issues (P3). Be direct — "this will crash when X" not "you might want to consider." Suggest fixes, don't just point out problems.
You are an autonomous sales agent. Your job: identify prospects, craft personalized outreach, follow up persistently but not annoyingly. Every interaction should provide value. Never be pushy. Build relationships first. Track all interactions in your CRM notes. Follow up within 24 hours of any response.
Track every task, decision, and commitment. When someone says something actionable, immediately create a task with priority, owner, and deadline. Never rely on "mental notes." Keep a kanban board updated. Flag blocked items daily. Your job is to ensure nothing falls through the cracks.
Write like a human, not a bot. No corporate speak. No filler. Every sentence should earn its place. Use short paragraphs. Break up walls of text. Lead with the most interesting thing. End with a clear call to action. Match the platform's tone (LinkedIn ≠ Twitter ≠ email).
Resolve issues on first contact whenever possible. If you can fix it, fix it — don't ask permission. Apologize genuinely when we're wrong. Never blame the customer. Escalate only when you genuinely can't resolve it. Follow up 24h later to confirm resolution.
Monitor, alert, fix. In that order. For every alert: (1) Acknowledge immediately, (2) Diagnose root cause, (3) Apply fix or workaround, (4) Document what happened, (5) Create a task to prevent recurrence. Never ignore alerts. Silence is failure.
Create a checkpoint of your current state. Include: what you're working on, key decisions made, blockers, and what should happen next. Format as YAML frontmatter + markdown body. This checkpoint should let a fresh agent resume your work seamlessly.
Summarize this session for your successor. Include: (1) What was accomplished, (2) What decisions were made and why, (3) What's still in progress, (4) What's blocked and on whom, (5) Any context that would be non-obvious to a fresh agent.
Compress this conversation into key observations. For each: assign priority (🔴 critical, 🟡 important, 🟢 background), categorize (decision/lesson/fact/commitment/relationship), and write a 1-2 sentence summary. Decisions are always at least 🟡. Commitments with deadlines are always 🔴.
You may have lost context from a previous session. Read your last checkpoint, recent daily notes, and MEMORY.md. Reconstruct: (1) What were you working on? (2) What was the last known state? (3) What needs to happen next? Report gaps in your knowledge.
Generate a daily note summarizing today's work. Format: ## Date, then sections for ### Completed, ### Decisions, ### In Progress, ### Blocked, ### Tomorrow. Use wiki-links for all entities ([[person-name]], [[project-name]]). Be concise but complete.
Review the last 7 days of daily notes. Extract significant events, lessons, and insights worth keeping long-term. Update MEMORY.md with distilled learnings. Remove outdated information. Think of this as a human reviewing their journal and updating their mental model.
Log this decision in the following format:
---
type: decision
date: [today]
title: [short title]
status: active
confidence: [high/medium/low]
---
## Context: [why this came up]
## Options Considered: [what alternatives existed]
## Decision: [what was decided]
## Rationale: [why]
## Implications: [what changes as a result]
Extract all people mentioned in this conversation. For each: name, role, organization, relationship to us, last interaction, key preferences or notes. Format as structured YAML. Flag any new relationships or changed dynamics.
Analyze my recent work logs and identify recurring patterns: (1) What tasks keep coming back? (2) What mistakes keep repeating? (3) What's taking longer than expected? (4) Where am I most productive? Suggest systemic fixes for the top 3 issues.
I have limited context space. Prioritize what goes in: (1) Current task requirements (must have), (2) Recent decisions and commitments (critical), (3) Relevant person context (important), (4) Background knowledge (nice to have). Cut ruthlessly. Every token counts.
21. "Store this as a [fact/decision/lesson/commitment]: [content]"
22. "What do I know about [person/project/topic]? Search all memory sources."
23. "List all open commitments with deadlines in the next 7 days."
24. "What decisions have I made about [topic]? Show rationale for each."
25. "Find contradictions in my stored beliefs about [topic]."
Break this into atomic, executable tasks. Each task should: take <30 minutes, have a clear done condition, have zero ambiguity about what "done" looks like. Order by dependencies. Flag any tasks that need human input.
Evaluate these tasks on two axes: Impact (1-10) and Effort (1-10). Plot on a 2x2 matrix: Quick Wins (high impact, low effort → do first), Major Projects (high impact, high effort → plan), Fill-Ins (low impact, low effort → batch), and Thankless Tasks (low impact, high effort → skip or delegate).
Given these tasks and a [X day] sprint, create an optimal plan. Consider: dependencies, energy levels (hard work AM, easy work PM), context switching costs, and buffer for unexpected issues. Aim for 70% planned capacity — the other 30% handles surprises.
29. "What's the single most impactful thing I can do in the next 30 minutes?"
30. "I'm stuck on [task]. Give me 3 alternative approaches I haven't considered."
31. "This task has been blocked for [X days]. Escalation plan: who to contact, what to say, deadline for response."
32. "Estimate time for [task]. Break into sub-tasks, estimate each, add 40% buffer. Be honest, not optimistic."
33. "Write a 'definition of done' for [project] that's testable and unambiguous."
34. "What are the hidden dependencies in this plan that could blow up?"
35. "Simplify this plan. What can I cut and still ship something valuable?"
I need to choose between [options] for [use case]. For each: (1) Pros/cons, (2) Performance characteristics, (3) Scaling implications, (4) Maintenance burden, (5) Community/ecosystem, (6) Your recommendation with confidence level. Be opinionated.
Design a REST API for [feature]. Include: endpoints, HTTP methods, request/response schemas, error codes, authentication, rate limiting, and pagination. Follow the principle of least surprise. Make the happy path obvious.
Write tests for [code/function]. Cover: happy path, edge cases, error cases, boundary conditions, and integration points. Each test should test ONE thing. Name tests as sentences that describe the expected behavior.
This code has a bug: [code]. Find it. Don't just identify it — explain: (1) What's wrong, (2) Why it fails, (3) Under what conditions, (4) The fix, (5) How to prevent similar bugs. Check for related issues nearby.
Refactor this code for: readability, maintainability, and performance (in that order). Show before/after. Explain each change. Don't refactor things that work fine — focus on the highest-impact improvements.
41. "Write a CLI tool in Node.js that [does X]. Include --help, error handling, and clean output."
42. "Convert this callback-based code to async/await. Handle all error paths."
43. "Write a Dockerfile for [project]. Multi-stage build, minimal image, non-root user."
44. "Create a GitHub Actions workflow for: lint, test, build, deploy to [platform]."
45. "Write a database migration for: [schema change]. Include rollback."
46. "Implement rate limiting for this API. Token bucket, configurable per-endpoint."
47. "Add structured logging to this codebase. Include: request ID, user context, timing."
48. "Write a health check endpoint that tests: DB connection, Redis, external APIs, disk space."
49. "Create an error handling middleware that: catches all errors, logs context, returns clean responses."
50. "Write a caching layer for [function]. TTL-based, cache invalidation on write, bypass option."
51. "Deep dive on [topic]. Give me the 20% of knowledge that covers 80% of use cases."
52. "Compare [A] vs [B] for [use case]. I want a clear winner, not 'it depends.'"
53. "What's the current state of the art for [problem]? Key papers, tools, and implementations."
54. "Analyze this market: size, growth, key players, gaps, and where a newcomer could win."
55. "Read this article and extract: key claims, evidence quality, counterarguments, and actionable takeaways."
56. "What are the top 5 risks of [approach]? For each: likelihood, impact, and mitigation."
57. "Synthesize these [N] sources into a coherent brief. Flag contradictions between them."
58. "What would [expert/framework] say about [problem]? Apply their mental model."
59. "Find holes in this argument: [argument]. Steel-man it first, then attack."
60. "What am I missing about [situation]? What's the thing I'm not seeing?"
61. "Write a cold email to [person] about [topic]. Max 5 sentences. Lead with value, not ask."
62. "Follow up on [previous email]. Reference specific detail from last interaction. Don't say 'just checking in.'"
63. "Write a LinkedIn connection request for [person]. 300 char max. Be specific about why."
64. "Draft a proposal for [client/project]. Executive summary first, details after. Clear pricing."
65. "Write a 'break-up' email for a prospect who hasn't responded after 3 follow-ups."
66. "Craft a customer success check-in email. Highlight specific value delivered. Ask one question."
67. "Write a launch announcement for [product]. 3 versions: email, LinkedIn, Twitter."
68. "Draft a partnership pitch to [company]. Focus on mutual value, not just what we want."
69. "Write an apology email for [issue]. Take ownership. Explain fix. No excuses."
70. "Create a referral ask email. Make it easy to forward. Include a clear one-liner about what we do."
71. "Write a LinkedIn post about [topic]. Hook in first line. No hashtag spam. End with a question."
72. "Turn this [data/finding] into a compelling story. Lead with the surprising insight."
73. "Write a Twitter thread (10 tweets) about [topic]. Each tweet should stand alone."
74. "Create a case study from [project]. Format: Challenge → Approach → Results → Lessons."
75. "Write SEO-optimized copy for [page]. Natural language, not keyword stuffing."
76. "Draft a product description for [product]. Benefits first, features second. One clear CTA."
77. "Write a 'how we built this' blog post about [project]. Be honest about mistakes."
78. "Create 5 ad copy variations for [product]. A/B test ready. Different hooks."
79. "Write a newsletter issue about [topic]. Insight → example → takeaway format."
80. "Turn this technical concept into an analogy a 12-year-old would understand."
81. "What did I do well today? What could I improve? Be specific, not generic."
82. "Review my last 5 decisions. Which ones would I change with hindsight? Why?"
83. "What's my biggest blindspot right now? What am I avoiding?"
84. "If I had to cut 50% of my current tasks, which ones would I keep? Why?"
85. "What would I tell myself 30 days ago? What do I wish future-me would remember?"
86. "Audit my tool usage. What am I underusing? What am I overcomplicating?"
87. "List my top 3 assumptions about [project/market/user]. How would I test each?"
88. "What's the laziest version of [goal] that still delivers value?"
89. "Where am I spending time on things that don't matter? Be brutal."
90. "Write a user manual for working with me. What should people know?"
91. "Design a cron job schedule for: email checks, calendar sync, memory maintenance, and health monitoring. Balance thoroughness with API costs."
92. "Build a webhook handler for [service]. Parse payload, validate, route to handler, respond quickly."
93. "Create a monitoring dashboard that shows: uptime, response times, error rates, and cost per operation."
94. "Design an alert system with 3 tiers: info (log only), warning (message me), critical (call me)."
95. "Build a data pipeline: ingest from [source], transform [how], store in [destination], alert on anomalies."
96. "Create a deployment script that: runs tests, builds, deploys, verifies health, rolls back on failure."
97. "Design a retry strategy for [API/service]. Exponential backoff, max retries, circuit breaker, fallback."
98. "Build a cost tracker that monitors API usage across all services and alerts when approaching budget."
99. "Create a nightly cleanup job: archive old logs, compress files, prune unused resources, report savings."
100. "Design an agent orchestration system where multiple agents can: discover each other, share context, delegate tasks, and avoid duplicate work."
- Copy-paste directly into ChatGPT, Claude, or your agent framework
- Customize the bracketed sections for your specific use case
- Combine prompts for complex workflows (e.g., #26 + #28 for sprint planning)
- Store your favorites in your agent's SOUL.md or system prompt
Built by Versatly. These are the actual prompts powering our production agents. https://whop.com/versatly-holdings/ | https://clawvault.dev