AI Strategies and Secrets

The real AI edge.

Not the obvious AI tips. The strategies, repos, and operator mindset that separate people who use AI from people who build with it. A practical field guide with notes you can test in your own workflow.

Claude vs CodexSecret promptsUseful reposOperator mindsetAI stackPower features

The workflow behind this site

Claude then Codex.

Plan with the deepest context you can get. Execute with the most autonomous implementation loop available.

01Claude

Architecture, design system, content strategy, complex reasoning, CLAUDE.md

02Codex

Implementation, automated testing, bug fixing, parallel tasks

03Claude

Review, refine, catch edge cases, update strategy based on results

04Codex

Ship, deploy, monitor — autonomously while you work on the next thing

Use the Right Tool

Claude vs Codex — a practical operator split

Skip benchmark chasing. The useful question is simpler: which tool should own the next step in the workflow?

C

Claude

Best when the work needs judgment, context, and careful writing

Long-form writing

Use it for brand voice, sales copy, explanations, policies, outlines, and anything where tone matters.

Planning before building

Give it the messy context, ask for tradeoffs, then turn the final plan into an implementation brief.

Document-heavy work

Useful for summarizing long notes, requirements, drafts, customer research, and multi-step workflows.

Human review still matters

Do not ship legal, medical, financial, or customer-facing output without reviewing facts and claims.

Good for: WritingGood for: PlanningGood for: ContextGood for: ReviewWatch: Blind executionWatch: Untested output
C

Codex

Best when the work needs code changes, tests, and repeatable execution

Implementation

Use it to edit files, run builds, fix failing tests, inspect a repo, and keep a task moving end to end.

Debugging loops

It is strongest when it can reproduce a bug, inspect logs, patch code, and rerun the same check.

Browser verification

For web apps, use it to confirm the rendered page actually matches the code and no overlay/errors appear.

Clear scope wins

The better the brief, the better the result. Give it target files, expected behavior, and what not to touch.

Good for: CodeGood for: TestsGood for: DebuggingGood for: VerificationWatch: Vague goalsWatch: Unsourced facts

The Operator Workflow

Plan with judgment. Ship with verification.

The clean workflow is not picking a favorite model. Use a reasoning assistant to clarify the plan, constraints, and copy. Use an execution agent to change files, run checks, and verify the result in the browser. Then review the final output before it touches customers.

Not in the documentation

Secret tips most people never find

Practical patterns for better AI output without hype. The headline and use case stay readable; the copy-paste examples are included below.

Claude-Specific

XML tags give Claude cleaner structure

Claude responds well to clearly separated instructions. Wrapping work in tags like <task>, <context>, and <format> keeps the output cleaner than one long paragraph.

Unlock code
<task>Write product descriptions</task>
<context>Shopify store, $40-80 price range, eco buyers</context>
<format>150 words, bullet benefits, no fluff</format>
<tone>Warm, direct, sustainability-focused</tone>

Practice note: use structure when accuracy matters more than speed.

Universal

Project instructions keep every session consistent

Put your stack, brand voice, commands, and no-touch rules in one project instructions file. That gives every AI session the same operating context.

Unlock code
# Project AI instructions
Stack: [framework + package manager]
Brand voice: [tone rules]
Commands: [typecheck], [build], [test]
Never touch: [files or checkout flows]
Review before done: [checklist]

Practice note: keep instructions versioned with the repo.

Prompting

Stable context first makes repeat work cheaper

Put the details that rarely change at the top, then place the new request at the end. This makes repeated AI work easier to review and can reduce cost when prompt caching applies.

Unlock code
// Structure: stable -> variable
[SYSTEM: brand voice, format rules]  <- cached
[CONTEXT: project background]         <- cached
[TODAY'S REQUEST: ...]                <- new each time

// Result: about 70% cheaper on repeated calls

Practice note: verify caching support and pricing with your AI provider.

Advanced

Meta-prompts: ask AI to write better prompts for you

Instead of struggling to write the perfect prompt, ask the AI to generate five versions and explain what makes each one different. Pick the strongest one.

Unlock code
Write me 5 variations of this prompt,
ranked from basic to expert-level.
Explain in one sentence what makes each
version stronger than the last.

My task: [describe what you want]

Practice note: compare prompt versions before saving one.

Memory

Audit memory before you rely on it

If your AI tool has memory enabled, audit what it remembers before you use it for brand, client, or strategy work. Bad memory creates bad assumptions.

Unlock code
Based on everything you remember about me:
1. Describe who I am and what I am building
2. How do I prefer to work?
3. What am I clearly avoiding?
4. Where is my thinking inconsistent?
5. What do I not say but clearly believe?

Practice note: use only with tools where memory is enabled.

Workflow

Repomix: turn an entire codebase into one AI-ready prompt

One terminal command can pack a repo into an AI-readable file for review, refactoring, or architecture work. It is useful when the AI needs broad context.

Unlock code
# Install
npx repomix --compress

# Count tokens before sending
npx repomix --token-count-tree

# Result: entire repo as one AI-ready file

Practice note: review output before sharing private code with any model.

Hidden

Model-specific formats: one size does not fit all

Different models respond better to different prompt shapes. Treat the formats below as starting points, then test against your own workflow.

Unlock code
Claude:     XML tags -> most precise
ChatGPT:    JSON schema -> most consistent
Gemini:     Markdown sections -> best for docs
Perplexity: Search-style queries -> better research
Codex:      Bullet spec lists -> cleanest code

Practice note: keep the format that produces the most usable output.

Efficiency

PromptFoo: test prompts like code, not guesses

Open-source tool that treats your prompts as testable code. Define expected outputs, run against multiple models simultaneously, and version your best prompts.

Unlock code
# Install
npx promptfoo@latest init

# Run tests across models
npx promptfoo eval

# Compare Claude vs GPT vs Gemini output
npx promptfoo view

Practice note: use prompt tests for workflows you repeat often.

Claude Code

A reusable project brief beats a blank chat

Before a coding session, give the AI the product goal, forbidden files, commands to run, and definition of done. The quality jump comes from context, not magic.

Unlock code
Goal: [what this change should accomplish]
Do not touch: [checkout, pricing, env files]
Use these checks: [typecheck], [build]
Done means: [behavior works], [page reviewed], [no risky copy]

Practice note: update the brief as the project changes.

Open-Source Tools

The repos worth knowing

A starter list of practical tools worth exploring. Verify repo activity, licenses, and setup requirements before using any of them in production.

superpowersOpen source
obra/superpowers
Repo details

A reusable skills and workflow system for AI-assisted development. Useful when you want project methods to travel from session to session.

Best for: adding repeatable working methods to AI coding sessions

Clone command
git clone https://github.com/obra/superpowers.git
ollamaOpen source
ollama/ollama
Repo details

Run supported language models locally. Good for experiments, sensitive drafts, and workflows where you do not want every task sent to an API.

Best for: offline AI and local model experiments

Clone command
git clone https://github.com/ollama/ollama.git
open-webuiOpen source
open-webui/open-webui
Repo details

A self-hosted AI chat interface that can connect to local and remote model providers. Useful for teams that want more control over their AI workspace.

Best for: team AI interfaces with more data control

Clone command
git clone https://github.com/open-webui/open-webui.git
langflowOpen source
langflow-ai/langflow
Repo details

Visual builder for AI workflows and agent pipelines. Good for prototyping before you commit to a custom backend.

Best for: mapping AI workflows before production buildout

Clone command
git clone https://github.com/langflow-ai/langflow.git
ComfyUIOpen source
comfyanonymous/ComfyUI
Repo details

Node-based workflow system for image generation. Useful when you need repeatable visual pipelines instead of one-off prompts.

Best for: repeatable image generation workflows

Clone command
git clone https://github.com/comfyanonymous/ComfyUI.git
promptfooOpen source
promptfoo/promptfoo
Repo details

Prompt testing and evaluation framework. Use it when a prompt becomes part of a real workflow and needs regression checks.

Best for: testing prompts across models and versions

Clone command
git clone https://github.com/promptfoo/promptfoo.git
repomixOpen source
yamadashy/repomix
Repo details

Packs repository context into an AI-readable format. Helpful for code review, architecture mapping, and refactor planning.

Best for: giving AI broad codebase context

Clone command
git clone https://github.com/yamadashy/repomix.git
n8nOpen source
n8n-io/n8n
Repo details

Workflow automation platform with AI and integration support. Useful for connecting forms, payments, emails, and internal operations.

Best for: automation workflows with human review points

Clone command
git clone https://github.com/n8n-io/n8n.git
the-book-of-secret-knowledgeOpen source
trimstray/the-book-of-secret-knowledge
Repo details

Large technical reference collection. Treat it as a research map, then verify anything important against primary documentation.

Best for: finding technical references and command patterns

Clone command
git clone https://github.com/trimstray/the-book-of-secret-knowledge.git

The Real Difference

The AI Operator Mindset

Users ask AI for answers. Operators use AI as a team. The mindset shift is small but the output gap is enormous.

01 / 04

Treat prompts like code, not requests

Requests are one-time. Code runs forever. Save your best prompts. Version them. Test them against multiple models with PromptFoo. Build a personal prompt library that compounds over time.

02 / 04

Give AI context, not just tasks

The difference between a good AI output and a great one is context depth. CLAUDE.md, Projects, Custom Instructions — every persistent context mechanism you use multiplies every future prompt.

03 / 04

Match the model to the job

Claude for reasoning and writing. Codex for autonomous execution. Gemini for research. Perplexity for live data. The cost of using the wrong model is not just output quality — it is your time spent correcting it.

04 / 04

Build systems, not outputs

A single AI-written blog post is an output. A content system with a brief template, research prompt, draft prompt, and edit prompt is a system. Systems compound. Outputs do not.

The Toolkit

The complete AI stack — what to use when

Use this as a starting map. Prices, model names, and plan limits change often, so verify the current plan before you buy.

C
Claude
Anthropic / claude.ai
Best for
Long-form writing, reasoning, architecture notes, brand voice, and careful review
Limitations
Tasks that need live web data or many parallel code edits
Price
Free and paid plans; verify current limits
C
Codex
OpenAI / ChatGPT or developer tools
Best for
Code changes, terminal debugging, browser verification, and shipping scoped fixes
Limitations
Requires clear repo boundaries and real checks before you trust the output
Price
Plan and usage vary by account
P
Perplexity
Perplexity AI / perplexity.ai
Best for
Live research, competitor analysis, fact-checking, and sourced claim discovery
Limitations
Final copy still needs human judgment and source review
Price
Free and paid plans; verify current limits
G
Gemini
Google / gemini.google.com
Best for
Google Workspace tasks, multimodal review, and research-heavy drafting
Limitations
Workflows outside the Google ecosystem may need extra setup
Price
Free and paid plans; verify current limits
G
Grok
xAI / grok.com
Best for
X/Twitter trend checks, audience language, and fast social context
Limitations
Not a replacement for primary-source research
Price
Access and pricing change often
O
Ollama + local models
ollama.ai / local machine
Best for
Sensitive drafts, offline experiments, and workflows where API cost matters
Limitations
Quality depends on your hardware and chosen model
Price
Software is free; hardware is the constraint
M
Midjourney
midjourney.com
Best for
Brand visuals, moodboards, marketing imagery, and aesthetic-first concepts
Limitations
Readable text and exact layout control often need another design tool
Price
Paid plans; verify current tiers
V
Veo
Google video generation tools
Best for
Short video concepts, cinematic clips, and campaign ideation
Limitations
Production control, brand consistency, and availability can vary
Price
Availability and pricing change often
E
ElevenLabs
elevenlabs.io
Best for
Voiceovers, narration, podcast drafts, and audio ad testing
Limitations
Voice rights, disclosure, and quality control still matter
Price
Free and paid plans; verify current limits

Pro Members Only / $19/mo

Use AI Like a Pro

Most people open Claude or ChatGPT and type. Pro members use reusable context, prompt libraries, and review loops so repeat work starts faster.

Unlocked for Pro MembersEverything below is included in your $19/mo subscription
Get Pro Access
Claude / Web Feature

Custom Instructions

Set your preferred context once so new conversations start closer to your brand voice, role, and response style.

Copy this into your workflow, adapt the brackets, and store the result in your personal prompt library.
Claude / Pro Feature

Claude Projects

Use Projects to keep related files, notes, and instructions together when you work on a business or client workflow.

Copy this into your workflow, adapt the brackets, and store the result in your personal prompt library.
ChatGPT / Web Feature

Custom Instructions

Same idea as Claude: give ChatGPT reusable context so routine conversations need less setup.

Copy this into your workflow, adapt the brackets, and store the result in your personal prompt library.
ChatGPT Plus / Advanced

Build Your Own Custom GPT

Create a specialized AI assistant pre-loaded with your profession's knowledge, your business details, and your communication style.

Copy this into your workflow, adapt the brackets, and store the result in your personal prompt library.
Any AI Tool / Workflow

Your Personal Prompt Library

When you find a version that works for your business, save it. A personal library of tested prompts compounds.

Copy this into your workflow, adapt the brackets, and store the result in your personal prompt library.
AI Memory / Audit

The Memory Audit Prompt

If memory is enabled, run an audit to see what the tool thinks it knows about you before it shapes future responses.

Copy this into your workflow, adapt the brackets, and store the result in your personal prompt library.
Design AI / Workflow

Design Brief Before Image Prompt

Write the audience, product, visual hierarchy, palette, and use case before asking for graphics. Better inputs make better assets.

Copy this into your workflow, adapt the brackets, and store the result in your personal prompt library.

Operator Pack

Want the complete AI operator kit?

Get the prompts, workflows, and guide library built for people who want to copy, paste, and ship instead of collecting generic tips.

Get Pro — $19/mo