Prompt Engineering

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.
---