Admin User

Fuck it.

I'm sharing the exact mega prompt that built my entire n8n automation empire.

This single prompt turns Claude into an n8n expert that designs, codes, and deploys AI agents from scratch.

Copy, paste, watch magic happen.

```
You are an expert n8n workflow automation engineer with 5+ years of experience building production-grade AI agents. Your task is to help me build a complete n8n AI agent workflow for [DESCRIBE YOUR USE CASE].

CONTEXT ABOUT MY NEEDS:
- Use case: [Describe what you want the agent to do]
- Data sources: [List your inputs - emails, APIs, databases, etc.]
- Desired outputs: [What should the agent produce/do]
- Integrations needed: [Slack, Gmail, Notion, etc.]
- Complexity level: [Beginner/Intermediate/Advanced]

REQUIREMENTS:
1. Design the complete workflow architecture
2. Provide step-by-step n8n node configuration
3. Include error handling and retry logic
4. Add data validation and transformation steps
5. Suggest optimization for production use

DELIVERABLES I NEED:
□ Workflow diagram description
□ Complete node-by-node setup instructions
□ JSON workflow file structure
□ Testing and debugging checklist
□ Scaling recommendations

TECHNICAL SPECIFICATIONS:
- Use Claude/OpenAI API for AI processing
- Include webhook triggers where applicable
- Add proper data sanitization
- Implement logging for troubleshooting
- Follow n8n best practices for node naming

CONSTRAINTS:
- Keep it production-ready, not a demo
- Optimize for reliability over complexity
- Include fallback mechanisms
- Make it maintainable by someone else

EXAMPLES TO INCLUDE:
- Sample input/output data formats
- Common edge cases and solutions
- Performance benchmarks if relevant

STEP-BY-STEP FORMAT:
1. Architecture overview
2. Node sequence with configurations
3. Connection mappings between nodes
4. Environment variables needed
5. Deployment checklist

Start by asking clarifying questions about my specific use case, then provide the complete implementation plan.
```

How to Use This Prompt

Step 1: Copy the mega prompt above

Step 2: Replace the bracketed sections with your specific details:

- Your use case (lead scoring, content creation, data sync, etc.)
- Your data sources and integrations
- Your complexity preferences

Step 3: Paste into Claude and watch it become your personal n8n consultant

Step 4: Follow the step-by-step instructions it provides

What are you going to build? Let me know in the comments...

Steal my Perplexity Prompt to research a profitable niche based on your topic.

-----------------------
NICHE RESEARCHER
-----------------------
 
#CONTEXT: 
Adopt the role of an expert researcher. Your task is to help the user trying to solve content creation challenges in their specific niche by conducting thorough research.

#ROLE: 
You are a research analyst specializing in identifying challenges and proposing innovative software solutions in various niches.

#RESPONSE GUIDELINES:
1/ Identify Key Challenges:
Provide 5 major challenges in the niche.
2/ Explain each challenge in detail, focusing on why it occurs, who is most impacted, and existing solutions.
3/ Propose Software Solutions:
For each challenge, propose a unique software idea.
4/ Break down each idea into core functionality, key features, value proposition, and potential tech stack.
5/ Cite Sources & Data Points:
Provide references for any statistics, facts, or expert opinions used.
6/ Conclusion & Next Steps:
Summarize the significance of the challenges.
Emphasize the potential impact of the proposed software ideas.
Suggest further reading or research paths.
Provide a detailed action plan for building the ideas with Cursor, assuming no programming experience.

#TASK CRITERIA:
- Focus on providing detailed explanations for each challenge and solution.
- Avoid overly technical jargon; ensure clarity for users without programming experience.
- Highlight the uniqueness and potential impact of proposed software solutions.

#INFORMATION ABOUT ME:
My subject or niche: [YOUR SUBJECT OR NICHE HERE]

#RESPONSE FORMAT:
Use bullet points for clarity.
Organize information into sections as outlined in the response guidelines.
Include a concise action plan or checklist at the end for easy reference.

This is my current @OpenAI Codex workflow.

It's insanely powerful, and allows Codex to implement far more complex features than the default setup.

It's also much more reliable and leads to better code, with significantly less scope creep.

Follow it exactly (models and all). The results are amazing:

Start by using this prompt (fill in your feature description), with gpt-5 high:

---
# Initial Explanation Stage

Your task is NOT to implement this yet, but to fully understand and prepare.

Here is exactly what I need implemented:

```[DETAILED FEATURE DESCRIPTION HERE]```

--

Your responsibilities:

- Analyze and understand the existing codebase thoroughly.
- Determine exactly how this feature integrates, including dependencies, structure, edge cases (within reason, don't go overboard), and constraints.
- Clearly identify anything unclear or ambiguous in my description or the current implementation.
- List clearly all questions or ambiguities you need clarified.

Remember, your job is not to implement (yet). Just exploring, planning, and then asking me questions to ensure all ambiguities are covered. We will go back and forth until you have no further questions. Do NOT assume any requirements or scope beyond explicitly described details.
---

Once you've answered all of GPT-5's questions and it has nothing more to ask, paste in this prompt:

---
# Plan Creation Stage

Based on our full exchange, now, produce a markdown plan document (`https://t.co/D3A6TySWHM`).

Requirements for the plan:

- Include clear, minimal, concise steps.
- Track the status of each step using these emojis:
  - 🟩 Done
  - 🟨 In Progress
  - 🟥 To Do
- Include dynamic tracking of overall progress percentage (at top).
- Do NOT add extra scope or unnecessary complexity beyond explicitly clarified details.
- Steps should be modular, elegant, minimal, and integrate seamlessly within the existing codebase.

Markdown Template Example:

```https://t.co/D3A6TySWHM (example)
# (Example) Feature Implementation Plan

**Overall Progress:** `0%`

## Tasks:

- [ ] 🟥 **Step 1: Setup authentication module**
  - [ ] 🟥 Create authentication service class
  - [ ] 🟥 Implement JWT token handling
  - [ ] 🟥 Connect service to existing database schema

- [ ] 🟥 **Step 2: Develop frontend login UI**
  - [ ] 🟥 Design login page component (React)
  - [ ] 🟥 Integrate component with auth endpoints
  - [ ] 🟥 Add form validation and error handling

- [ ] 🟥 **Step 3: Add user session management**
  - [ ] 🟥 Set up session cookies securely
  - [ ] 🟥 Implement session renewal logic
  - [ ] 🟥 Handle session expiry and logout process

...
```

Again, for clarity, it's still not time to build yet. Just write the clear plan document. No extra complexity or extra scope beyond what we discussed. The plan should lead to simple, elegant, minimal code that does the job perfectly.
---

Now, once this plan is done, look it over, and if it looks good, switch the model to gpt-5-codex high, then prompt it with:

---
Now implement precisely as planned, in full.

Implementation Requirements:

- Write elegant, minimal, modular code.
- Adhere strictly to existing code patterns, conventions, and best practices.
- Include thorough, clear comments/documentation within the code.
- As you implement each step:
  - Update the markdown tracking document with emoji status and overall progress percentage dynamically.
---

💡CLAUDE[.]md Tips & Tricks (Cheatsheet)

CLAUDE[.]md is one of the most important files in any Claude Code project. Think of it as project memory + execution guidelines.

It tells Claude what your project is, how the codebase is structured, what design rules to follow, and what patterns to avoid.

Here are 8 practical tips for writing a better CLAUDE[.]md:

1⃣ Know the difference between project and global CLAUDE.md

A project-based CLAUDE[.]md lives in your project root and is specific to that product.
A global CLAUDE[.]md lives in your Claude env and defines reusable preferences across all projects.

Project CLAUDE.md = project context
Global CLAUDE.md = personal working style

2⃣ Structure it properly

Claude performs better when information is grouped semantically.
Thats why don’t write random instructions.

Use clear sections like:
✅ Project Overview
✅ Tech Stack
✅ Folder Structure
✅ UI/UX Principles
✅ Component Rules
✅ Accessibility Requirements
✅ Testing Strategy
✅ Content Guidelines
✅ Deployment Notes

3⃣ Use [/]init to create the first draft

You don’t need to start from a blank page.
Run [/]init so Claude Code will scan your project and generate a first version of CLAUDE[.]md
It won’t be perfect, but it gives you a solid starting point.

4⃣ Keep it short

CLAUDE[.]md is loaded into every Claude Code session, so it consumes context.

My rule of thumb: Keep it under 200 lines.
Ideally, under 100.

For detailed documentation, use routing rules

5⃣ Be specific

Bad instruction: “Write clean code.”
Better instruction: “Use descriptive prop names, no abbreviations” and “Prefer composition over inheritance.”

The more precise your instructions are, the more deterministic Claude’s output becomes.

6⃣ Treat CLAUDE.md as a living document

Don’t create it once and forget it.

Update it when:
✅ Claude repeats the same mistake
✅ You introduce a new pattern
✅ Your product requirements change
✅ Your design system evolves
✅ Your team agrees on new rules

The best CLAUDE.md files are built from real usage, not theory.

7⃣Use [.]claude/rules for modular instructions

Instead of putting everything into one file, split rules by topic and then reference them from CLAUDE[.]md or directly in Claude Code chat.

This creates cleaner, more focused context.

8⃣ Commit CLAUDE[.]md to Git

Your project-based CLAUDE.md is part of your project infrastructure.

When you commit it to Git, the whole team gets more consistent AI behavior.

Complete guide 👇

My fav way to un-slop a codebase:

- find large files
- ask to break up, improve code quality, add tests
Once done, ask "now that you read the code, what can we improve?"
- store that in a tracker file (i use docs/refactor/*.md) and let the model pick
- do one by one

I'm Boris and I created Claude Code. I wanted to quickly share a few tips for using Claude Code, sourced directly from the Claude Code team. The way the team uses Claude is different than how I use it. Remember: there is no one right way to use Claude Code -- everyones' setup is different. You should experiment to see what works for you!

1. Do more in parallel

Spin up 3–5 git worktrees at once, each running its own Claude session in parallel. It's the single biggest productivity unlock, and the top tip from the team. Personally, I use multiple git checkouts, but most of the Claude Code team prefers worktrees -- it's the reason @amorriscode built native support for them into the Claude Desktop app!

Some people also name their worktrees and set up shell aliases (za, zb, zc) so they can hop between them in one keystroke. Others have a dedicated "analysis" worktree that's only for reading logs and running BigQuery

See https://t.co/yXde5dW1vZ

Claude Code tips that have made my life easier:

(Add these to your CLAUDE .md file)

1. "Before writing any code, describe your approach and wait for approval. Always ask clarifying questions before writing any code if requirements are ambiguous."

2. "If a task requires changes to more than 3 files, stop and break it into smaller tasks first."

3. "After writing code, list what could break and suggest tests to cover it."

4. "When there’s a bug, start by writing a test that reproduces it, then fix it until the test passes."

5. "Every time I correct you, add a new rule to the CLAUDE .md file so it never happens again."

The wording in the file is much more detailed than what I wrote above, but hopefully these show the spirit.