Our newest Claudify 2.0 version just launched today.. 500+ active users and counting 👀

CLAUDE PROMPT OF THE WEEK ↴ Turn your own repeated task into a ready-to-run chain Every codebase has a multi-step task someone runs by hand, the same way each time. This prompt reads your project, finds one recurring task, and writes the complete shell function for it, gated so a broken step stops the chain early. ----- You are a pipeline architect. Your job is not to write generic automation advice. Your job is to find the one multi-step task this specific developer already does by hand, then write the exact chained `claude -p` function that replaces it, wired to this project's real files. **Step 1. Investigate before proposing anything.** Read `README.md`, `package.json` or the project's manifest file, and `CLAUDE.md` if present. Run `git log --oneline -30` to see what kind of changes actually happen here. Glob for test, build, and lint config. Do not invent a workflow. Find the one this developer actually repeats: reviewing a diff before merging, auditing a directory for a known problem, migrating a pattern across files, anything with a clear investigate-then-decide-then-act shape. **Step 2. Design a 3 or 4 step chain, capped at 4.** Each step is one focused `claude -p` call. Step 1 is always read-only (`--allowedTools "Read,Grep,Glob"`). The last step is the only one allowed to write. Every step's result is captured with `--output-format json | jq -r '.result' > stepN-name.txt`, and every step but the last is followed by a non-empty-file gate that aborts the chain with a clear message if the file is empty. Name the files after what they contain, not their step number alone: `findings.txt`, not `output1.txt`. BAD step name: `claude -p "look at the code" > out.txt`. WHY: vague prompt, vague filename, nothing to gate on, no idea what "look at" means when re-read cold. GOOD step name: `claude -p "List every route in src/api missing a rate limiter. Name the file and line." --allowedTools "Read,Grep" --output-format json | jq -r '.result' > unrated-routes.txt`. The prompt is specific enough that step 2 can act on the file without re-reading the codebase. **Step 3. Output the complete shell function.** One fenced bash block, ready to paste into a shell profile or a script. Comment each step with what it does and what it reads. End the function by printing the names of every file it produced, so the developer knows what to open first. **Step 4. Self-grade before outputting.** Score 1 to 5: (1) the chosen task is one this project's evidence actually supports, not assumed, (2) every prompt inside every step is specific enough to run unattended, (3) every step but the last has a working abort gate, (4) the function uses only Bash, `claude`, and `jq`, nothing else. Rewrite anything below 4. Print the scores, then the final function. Close by naming the one intermediate file most likely to reveal a bad chain early, and why that one first.

CLAUDE PROMPT OF THE WEEK ↴ This prompt reads your project's actual git history and directory layout to identify which operations are risky for this specific codebase, then generates a .claude/settings.json permissions block with allow and deny rules calibrated to what this project actually needs. No guessing. No generic deny list. One ready-to-commit file with an explanation of each rule's rationale. ---- You are a permissions auditor dropped into an unfamiliar project with 20 minutes to read its structure and write rules that match what this project actually does. Not a generic template. Evidence first, rules second. Step 1: Read the project structure. Use Read, Bash, and Glob. Bash: find . -maxdepth 3 -type f -name "*.json" -o -name "*.yml" -o -name "*.yaml" -o -name "*.sql" -o -name "migration*" -o -name "schema*" 2>/dev/null | head -30 This tells you: does this project have a database layer? Migration files mean db-altering commands need human sign-off. Bash: git log --oneline -30 2>/dev/null || echo "no git history" Bash: git remote -v 2>/dev/null || echo "no remotes" If a remote exists, Bash(git push *) is the first deny rule. If no git history, rely on directory structure only. Read: package.json, pyproject.toml, Cargo.toml, go.mod, or the equivalent -- whichever exists. The scripts section reveals which Bash commands Claude should be allowed to run. Bash: ls .claude/ 2>/dev/null Read any existing .claude/settings.json -- your output should merge with it, not overwrite it. Step 2: Write rules from what you found. Do not copy a generic template. Pattern syntax: ToolName(command *) with a space before the asterisk. Bash(npm run *) allows any npm run command. Bash(git push *) blocks all push variants. A bare "Bash" removes the entire tool from context. A bare "Write" does the same for file writes. Scoped patterns block specific commands; bare names remove the tool completely. Anti-pattern: BAD: deny "Bash(rm -rf *)" with rationale "rm is dangerous" WHY: every project has rm. If you cannot cite a specific file or structural signal that makes rm risky here -- a cleanup script, a deploy pipeline, migration files -- the rule is boilerplate, not analysis. GOOD: deny "Bash(rm -rf *)" with rationale "deploy/ directory contains irreversible cleanup scripts; manual rm only" Calibration: a strong output has one sentence of evidence per rule that names a file path, a directory, or a git commit. A weak output lists rules that could apply to any project. Step 3: Output. First write a "Rule rationale" section: one sentence per rule, each citing a specific file or finding. Then output the complete .claude/settings.json block as valid JSON with no comments inside it. Self-check before outputting (score each 1 to 5): - Evidence: every rule cites a file, directory, or log entry from this project - Syntax: patterns use ToolName(command *) with space before asterisk; bare names only for total removal - Validity: the JSON is syntactically correct, ready to commit Rewrite anything below 4. Then output your Rule rationale, the settings.json block, and one sentence on what to try first in a session to confirm the deny rules are working.

CLAUDE PROMPT OF THE WEEK ↴ Know exactly what /rewind can and cannot undo before you reach for it The hardest part of session recovery is not knowing which tool to reach for. /rewind restores file edits Claude made through its tools; it cannot restore anything a bash command changed. This prompt reads your git diff since the last checkpoint, classifies every change by how it was made, and tells you which recovery tool is the right call before you run either one. ----- You are a recovery triage specialist. Your job is not to fix anything. Your job is to read the evidence in the git diff, classify every changed file accurately, and tell the developer exactly which recovery tool applies to each change before they reach for it. Run these commands: 1. `git log --oneline -20` -- find the most recent checkpoint commit (message contains "checkpoint") or the commit from the last 4 hours 2. `git diff HEAD` -- if no checkpoint, use this to see all uncommitted changes 3. `git diff ..HEAD --stat` -- if a checkpoint exists, use this instead 4. `git show ..HEAD --name-status` -- list all files touched since the checkpoint 5. `git log ..HEAD --oneline` -- list any commits made during the session For each file that changed, classify it under one of two categories: REWINDABLE: the change was made through Claude's file editing tools (Write, Edit, MultiEdit). /rewind can restore this file to its pre-session state. Evidence: the file appears in the diff but no bash command in the session log produced it. REQUIRES MANUAL REVIEW: the file was touched by a bash command Claude ran (rm, mv, cp, npm install, git operations, script execution, test runners that write output). /rewind does not track these. Evidence: look for lock files updated (package-lock.json, yarn.lock), generated files with no corresponding source edit, files in build/dist directories, test output files, files with permissions changes. BAD output looks like this: "package-lock.json: changed (check manually)" WHY that fails: it gives the developer no information they did not already have. GOOD output looks like this: "package-lock.json -- REQUIRES MANUAL REVIEW. Lock files are written by npm/yarn bash commands, not by Claude's file tools. /rewind cannot restore this. Recovery: git checkout HEAD -- package-lock.json, or git stash, or git reset --hard HEAD~1 if you ran the checkpoint step." The distinction matters at the worst possible moment. A misclassified file gives the developer false confidence in /rewind and they discover the limit only after it fails. Output one table with these columns: - File path - Classification (REWINDABLE / REQUIRES MANUAL REVIEW) - Evidence (one sentence: what signals this classification) - Recovery command (the exact command to use, not a category) Below the table: one paragraph summarising how many files fall into each category and which recovery path to start with. Before you output, score yourself on these four criteria (1 to 5): - Accuracy: is every classification defensible from the evidence in the diff? - Completeness: have I covered every changed file, no skips? - Actionability: does every row give a specific recovery command? - Honesty: have I flagged any ambiguous files as REQUIRES MANUAL REVIEW, not assumed REWINDABLE? Rewrite any criterion below 4. Then output. If the git diff is empty or the repository has no commits, say so plainly and stop. Do not invent a triage where there is nothing to triage.

CLAUDE PROMPT OF THE WEEK ↴ Build a pre-populated agent that already knows your codebase The agent file above starts with an empty MEMORY.md. That means the first few sessions are spent discovering things about your codebase that are already visible in the files. This prompt reads your project to find its existing patterns, decisions, and file layout, then generates a complete agent definition with a MEMORY.md already seeded with the first three entries in each of the four sections, drawn from what it actually found. The agent starts its first real run already knowing the project. ---- You are the codebase archaeologist for this project. Read the repo, decide which specialist agent it most needs, and seed that agent's memory before its first run, so it starts informed instead of rediscovering the project over five sessions. STEP 1: PICK THE SPECIALISM If the user named the agent's role, use it. Otherwise infer the single most valuable specialist for THIS repo from its shape: - App with auth, a database, or API calls: a security and data-integrity reviewer. - Rendering, UI, or media engine: an output-correctness reviewer. - Library, CLI, or build-tooling repo: a build and interface-integrity reviewer. State the chosen role in one line and why the repo points to it. STEP 2: INVESTIGATE Use Read, Grep, and Glob to answer four questions, framed for the chosen role. Read the dependency file first (package.json, pyproject.toml, go.mod, Gemfile, or equivalent). - Decisions: the architectural or team choices the agent must respect. - Patterns: the conventions consistently in use. Grep for the role's signals (validate/token for security, prop/frame for rendering, export/schema for tooling). - Anti-patterns: the shortcuts or smells worth flagging (TODO, FIXME, raw SQL, unvalidated input, missing types). - Codebase facts: the layout to orient. Entry point, core module, relevant directory, shared helpers. Calibration for every entry: BAD: "Validation may be in use." WHY: an agent cannot act on a guess. It needs a confirmed fact with a location. GOOD: "All inputs pass through validate() in src/lib/validate.ts. Any handler that skips it is a gap." Every entry cites a real file path and, where it helps, a function or line. STEP 3: GENERATE TWO FILES File 1, .claude/agents/.md, with frontmatter: --- name: description: . Use when . tools: Read, Grep, Glob, Write model: sonnet memory: project --- The Write tool is required: without it the agent cannot update its own memory. Write a system prompt body directing the agent to cite each finding with path and line, state the risk and fix, then append only new entries to MEMORY.md under the four headers after each run. File 2, .claude/agent-memory//MEMORY.md, with the four section headers. Seed each section with every fact you confirmed in Step 2, up to four per section. Quality over count: one real entry beats three invented. Never pad or write a placeholder. If a section holds one honest fact, write one. SELF-GRADE before output. Per section, score 1 to 5 on Specificity (real path and concrete fact, not filler) and Usefulness (would the agent skip sessions of discovery). Rewrite anything below 4. If a section is thin because the repo lacks that surface, say so rather than inventing entries. OUTPUT State the self-grade scores. Output both files in full, each in its own fenced block labelled with its path. End with one sentence naming what the agent knows on its first run that a blank-slate agent would not.

As we roll out our new and improved Claudify 2.0 version on the 1st July, this is your last chance to get the full system at 50% off (and have access to the new version for free) 🔥

CLAUDE PROMPT OF THE WEEK ↴ Build a ship function tailored to this exact repo The function above uses npm test as a placeholder and a generic commit message prompt. This prompt reads your project's actual test config, your recent PR titles, and your commit history, then generates a ship function tuned to this repo's conventions, ready to drop into your shell config in one paste. No guessing at the test command. No generic message style. -- You are a shell contractor who reads before writing. Read this project's files and output one complete, repo-specific `ship` function, ready to paste into a shell config. Assume nothing about the stack. **Step 1. Investigate, do not guess.** Read whichever exist at the root: `package.json`, `Makefile`, `go.mod`, `Gemfile`, `pyproject.toml`, `Cargo.toml`, `README.md`. If the root is a near-empty stub, look one level down for the real project. Pull two things. The gate command: check `scripts.test` in `package.json`, a `test` target in the `Makefile`, or a "run tests" line in the README, and use it exactly. If none exists, do not fall back to a bare `pytest` or `go test` that collects nothing; use the project's build or type-check instead (`npm run build`, `npx tsc --noEmit`, `cargo build`, `go build ./...`) and label it a stand-in. The commit style: run `git log --oneline -20` and note the prefix convention and subject length. If there is no history, say so and set one clean default. **Step 2. One clarifying question only.** If the base branch is not clear from the git log, ask which branch PRs target, then wait. Ask nothing else. **Step 3. Output the function.** Replace `[GATE]` with the Step 1 command and `[STYLE]` with a one-line style instruction from the history. ```bash ship() { git rev-parse --is-inside-work-tree >/dev/null 2>&1 || { echo "Not a git repo."; return 1; } if git diff --staged --quiet; then echo "Nothing staged."; return 1; fi HISTORY=$(git log --oneline -10 2>/dev/null || echo "") COMMIT_MSG=$(git diff --staged | claude -p \ --allowedTools "Bash(git diff *),Bash(git log *)" \ "History for style: $HISTORY Write a commit message for the staged changes. [STYLE]") if [ $? -ne 0 ] || [ -z "$COMMIT_MSG" ]; then echo "Message failed."; return 1; fi printf '%s\n' "$COMMIT_MSG" if ! [GATE] 2>&1; then echo "Checks failed. Nothing committed."; return 1; fi git commit -m "$COMMIT_MSG" && \ git push --set-upstream origin "$(git branch --show-current)" && \ gh pr create --fill --web } ``` Do not add `gh pr merge`. The function opens the PR and stops. Review stays human. BAD: hardcoding `npm test` unchecked, with a style line like "write a clear message." Most projects do not run on npm, and generic instructions produce generic messages. GOOD: `pytest -q` when `pyproject.toml` and real test files confirm it; `npm run build` when there is no suite but a build exists; a style line drawn from twenty real commits. **Step 4. Hand it over.** After the function, output three lines: the `source` command, an example first run, and one sentence naming the gate command, how you found it, and whether it is a real test command or a build stand-in. **Step 5. Self-grade, then finish.** Score four criteria 1 to 5 and rewrite anything below 4: Inferred, Exact, Tailored, Complete. Print one line of scores. When all four are 4 or higher, output the final function and stop.

Join our community of over 500 users before our prices increase next month 👀💻 claudify.tech/

PROMPT OF THE WEEK 💻👇🏼 Audit your project and generate ready-to-run mcp add commands Most developers look at their codebase and assume they know which external systems it touches. The actual count is usually higher once you read the dependency files, the README, and the environment variable names together. This prompt does that read, infers every connected system, and outputs a shell script of exact claude mcp add commands tailored to this specific project, with the correct transport, headers, and scope recommendation for each one. -- " You are an MCP scout: before any other work, you inspect this project and hand back a ranked, ready-to-run plan of the MCP servers worth connecting to Claude Code, each with the exact `claude mcp add` command. You recommend only servers that match what this project actually uses, and you connect nothing yourself. **Step 1. Read the stack, do not guess it.** Read the manifests and config that exist (package.json, requirements.txt, go.mod, Gemfile, docker-compose.yml, .env.example, the README). From them, list the concrete services this project touches: the database and its engine, the version-control host, error tracking, browser testing, deploy targets, and any external API the code calls. If a category has nothing, skip it. Never recommend a server for a tool the project does not use. **Step 2. Map each finding to one real MCP server.** For each service, name the server that fits and pick the transport: `--transport http` for a hosted remote server (for example GitHub), `--transport stdio` for one that runs as a local process (for example a database server launched with npx). Pick the scope: `--scope project` when the team should share it (writes a committable `.mcp.json`), `--scope user` when it is personal across projects. Flag any credential that should be read-only or least-privilege. **Step 3. Output the plan as ranked, copy-paste commands.** Rank by leverage for this project, highest first. For each: the server, a one-line reason citing something you actually found, and the exact command with placeholders. ``` 1. GitHub (this repo has .github/ workflows) claude mcp add --transport http github api.githubcopilot.com/mcp/ \ --header "Authorization: Bearer YOUR_GITHUB_PAT" --scope project ``` BAD: "You should connect a database MCP server." That is advice, not a plan. GOOD: the block above, where the command runs after the reader swaps the placeholder, the transport matches local vs remote, and the reason cites a real file. **Step 4. Self-grade, then hand it over.** Score four criteria 1 to 5 and rewrite anything below 4: Match (every server maps to something you actually found, no filler), Correctness (right transport and scope per server), Safety (least-privilege flagged, no real secret printed), Runnable (each command runs after the placeholder swap). Output the scores on one line: Match:N Correctness:N Safety:N Runnable:N When all four are 4 or higher, end with: "Start with number 1. Run it, then `claude mcp list` to confirm, then give Claude a real task that uses it." Then stop. " -- Review the shell script before running it. Each command includes a --scope recommendation: local for personal tokens, project for servers the whole team should share. Cut any server your project does not actually use. Run the ones that remain, then type /mcp inside a Claude Code session to confirm they are live.

How many times have you re-explained your project to Claude today? Same context. Same corrections. Same wasted time. Claudify gives your AI coding tool persistent memory, specialist agents, and automated quality checks. One install. Works in Claude Code, Cursor, Windsurf.

CLAUDE PROMPT OF THE WEEK ↴ Build a complete subagent definition from any task description: You are a scope-first contractor. Your job: read this project, identify the task that repeats most, and design a specialist subagent for it. Every tool in the allowlist is a liability. Every tool you omit is a guard. Build the tightest possible agent that does exactly one thing well. Start by reading the project: 1. Read CLAUDE.md if it exists. Note any recurring tasks, named workflows, or repeated pain points. 2. Run: ls -la .claude/agents/ 2>/dev/null to see what agents already exist. 3. Find and read the project manifest (package.json, pyproject.toml, go.mod, Cargo.toml, whichever exists). Note the stack and scripts. 4. Run: git log --oneline -20 2>/dev/null to see what work has repeated recently. 5. Read 3-5 source files that appear most frequently in that git history. Based only on what you found (not general intuition), identify the single most-repeated manual task in this project. Name the file evidence that points to it. Then design the agent: FRONTMATTER (required fields): - name: kebab-case slug, matches the filename - description: trigger condition, not a job title. Format: "Does X. Use when Y." This is how Claude decides when to delegate. - tools: minimum allowlist. Read, Grep, Glob for read-only work. Add Write or Edit only if the task requires file changes. Add Bash only if shell execution is unavoidable. Never add tools speculatively. - model: haiku for mechanical, well-defined tasks. Omit for agents that need reasoning. SYSTEM PROMPT BODY (required structure): - One sentence: the agent's single job, no more. - Explicit output format: what it returns, how it is structured. - One named anti-pattern: show a bad output example and explain why it fails. - One instruction: "After each session, append any conventions you discovered to .claude/agent-memory/{name}/MEMORY.md." ANTI-PATTERN to avoid in your system prompt: BAD: "You are a helpful assistant. Review the code and provide feedback." WHY: no scope, no format, no memory, no anti-pattern. Every run produces different-shaped output. The agent never learns. GOOD: "You audit API response shapes against the types declared in src/types/. Return each mismatch as: file path / line number / expected type / actual shape. Never suggest architectural changes. Append any type conventions found to .claude/agent-memory/type-auditor/MEMORY.md." Self-score before submitting (1-5 each): - Scope: is every tool in the allowlist actually required, or did you add it speculatively? - Precision: does the system prompt output format specify exactly what a returned item looks like? - Evidence: is the agent grounded in something you actually read, not something you assumed? Rewrite any criterion below 4. Then output: 1. The task you identified and the file evidence for it (2-3 sentences) 2. The complete agent file, fenced, ready to save as .claude/agents/{name}.md 3. One command: mkdir -p .claude/agent-memory/{name} 4. One line: how to invoke the agent once the session restarts

We're extremely excited to launch our first subscription-based product next week, dedicated to developers, software engineers, AI-focused builders and all tech savvy people! Join 500+ Claudify users, as our first three months since launch come to a close, where the Launch Pricing of our current products will no longer be in effect soon ⏰ And for those who just want some free value, you can also join our newsletter here claudify.tech/newsletter

Join our free AI newsletter - claudify.tech/newsletter We're giving you specific techniques that save developers HOURS every week! Join developers already shipping faster with Claude Code for free, every Tuesday.

Having only launched two months ago now, we're already trusted by over 500+ developers / AI-focused builders, and still growing.. here are some of our users' reviews: "It’s literally my go to. Can’t work without it" (Marco, website-building specialist) "LOVE your products" (Manu, Amazon specialist seller) Check out our latest product launches at: claudify.tech/

🎉🏆 Winners of the last week's DevHunt!🎉 Our top 3 champs are: 1⃣🥇 Claudify by claudify.tech – best Dev Tool of the week!!! → devhunt.org/tool/claudify 2⃣ NoteGPT.io 🥈 → devhunt.org/tool/notegpt-ai-… 3⃣ Link Grabber by @db_the_first 🥉 → devhunt.org/tool/link-grabbe… Keep up the great work, everyone! 👍

Claudify by claudify.tech is a production-grade operating system for Claude Code! ⇨ Build faster with 1,727 skills, specialist agents, and layered memory that keeps work consistent! Learn more: devhunt.org/tool/claudify

👋 Friends! ⏰Just 12 hours left to vote for your favorite developer tool at DevHunt. 23 amazing devtools are competing for the "Tool of The Week" title 🥇 Finalists : → Claudify.tech → NoteGpr.io → Link Grabber by @db_the_first → Format JSON Online by @formatjson75 → NanoBanana.Art Your vote is important, so don't miss out! → devhunt.org

Our new tool Claudify just launched on DevHunt! 1,727 skills. 9 agents. Persistent memory. The complete operating system for Claude Code. claudify.tech/ If you've tried it and it's helped your workflow, an upvote would mean a lot: devhunt.org/tool/claudify