Tech Bright Tips

𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 𝗶𝘀 𝗻𝗼𝘁 𝗮 𝗥𝗘𝗔𝗗𝗠𝗘.
𝗜𝘁'𝘀 𝗼𝗻𝗯𝗼𝗮𝗿𝗱𝗶𝗻𝗴 𝗱𝗼𝗰𝘀 𝗳𝗼𝗿 𝘆𝗼𝘂𝗿 𝗔𝗜 𝘁𝗲𝗮𝗺𝗺𝗮𝘁𝗲.

Most developers write a CLAUDE.md with a few bullet points and wonder why Claude keeps ignoring their patterns.

Here's the framework that fixes it:

🌐 Use all 3 scopes
→ Global (your defaults)
→ Project (team rules)
→ Folder (module overrides)
→ Last scope wins on conflicts

🧠 Apply WHAT / WHY / HOW
→ WHAT — project name, tech stack, repo structure
→ WHY — architecture decisions, naming conventions
→ HOW — build, test, lint, commit, deploy commands

✗ Stop being vague
→ "Write clean code" = ignored
→ "camelCase for variables, PascalCase for components" = followed

⚙️ 5 rules that make it work
→ Run /init first, then curate
→ Stay under 500 lines
→ Use Hooks for 100% enforcement
→ Update monthly
→ Reference files, don't duplicate them

Save this for your next Claude Code project.

Comment below 'Guide' I will send you detailed flow with related docs.

Your RAG pipeline has 3 levels. Most teams are stuck on Level 1.

Here's the evolution:

𝗟𝗲𝘃𝗲𝗹 𝟭 — 𝗖𝗹𝗮𝘀𝘀𝗶𝗰 𝗥𝗔𝗚
Query → Embed → Vector DB → Top-K Chunks → LLM → Answer
It retrieves. It's fast. It's simple.
But it's single-hop — ask a question that connects two documents and it fails silently. No understanding of relationships between entities.

𝗟𝗲𝘃𝗲𝗹 𝟮 — 𝗚𝗿𝗮𝗽𝗵 𝗥𝗔𝗚
Query → Entity Extraction → Knowledge Graph → Connected Context → LLM → Answer
Now you're traversing relationships, not just matching embeddings. Entities, edges, connections. The context sent to the LLM is structured, relational, and multi-source. This is where most enterprise use cases should be heading.

𝗟𝗲𝘃𝗲𝗹 𝟯 — 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗥𝗔𝗚
Query → Reasoning Agent → (Vector DB + Knowledge Graph + Web Search + Tools) → Self-Evaluation → Final Answer
The system doesn't just retrieve — it reasons about what to retrieve, from where, and whether the answer is good enough. If not, it loops back. Adaptive. Multi-step. Self-correcting.

The key insight — these aren't competing approaches. They're a maturity curve:

→ Classic RAG to prove value fast
→ Graph RAG when entity relationships matter
→ Agentic RAG when you need reasoning, not just retrieval

The biggest mistake? Jumping to Level 3 without mastering Level 1. Or worse — staying at Level 1 and wondering why production accuracy won't cross 60%.

Save this. Bookmark it. Share it with your team.

Where are you right now — Level 1, 2, or 3? 👇

Everyone talks about GPUs.
Almost nobody talks about the other 5 chips that make AI actually work.

6 processors power modern AI 👇

CPU → The Generalist
Orchestrates everything. The project manager.

GPU → The Parallel Powerhouse
16,896 cores on H100. Training at scale.

TPU → The Tensor Specialist
Google-built. 2x cheaper than GPU at scale.

NPU → The Edge Executor
On-device inference at single-digit watts.

LPU → The Speed Demon
Groq-built. 241 tokens/sec. 500 words in ~1 second.

DPU → The Infrastructure Offloader
Networking, storage, security — all in hardware.

AI does not run on one chip. It never did.

Every major AI company is making bets across this stack right now.

Full visual breakdown in the post.
Save it. Send it to someone learning AI.

Follow Tech Bright Tips for more visual breakdowns on AI architecture.

If you're building AI agents and you haven't studied this architecture, you're building blind.

New post breaks it all down ↗️

When you use Claude Code, you think you're talking to a model.

You're not.

You're talking to a 46K-line query engine that decides what the model sees, what tools it can touch, and when to stop.

Here's what happens when you type "fix this bug" 👇

Layer 1 → CLAUDE.md
Before reading your code, Claude reads this file. Your architecture. Your conventions. Your guardrails. Without it, Claude guesses. With it, Claude follows your playbook.

Layer 2 → The Agent Loop
Not a single API call. A loop: Gather Context → Take Action → Verify → Repeat. A bug fix might cycle dozens of times.

Layer 3 → 50+ Tools
Without tools, Claude only responds with text. With tools, it acts. File ops, Bash, Grep, Web fetch, and AgentTool — sub-agents as first-class citizens of the same registry.

Layer 4 → Permissions
Every tool call hits a 4-step cascade: Rules → Tool logic → Mode check → Classifier → User prompt. Fail-open means "ask the user," not "execute anyway."

Layer 5 → Skills + Hooks + MCP
Skills shape behavior. Hooks fire at lifecycle moments. MCP connects external services. All same interface. MCP hit 97M installs because of this.

The big insight?

You were never talking to a model. You were talking to a 46K-line query engine, a 5-layer compaction system, and an 8-layer security model.

The era of "just call the API" is over.

Save this for later 🔖

RAG has three generations. Most teams are still on the first one. 🧠

Classic RAG → Retrieves
Fast, simple, single-hop. Perfect for FAQs and policy lookups.

Graph RAG → Connects
Entity-rich and relational. Shines when the answer lives *between* documents, not inside them.

Agentic RAG → Reasons
Adaptive, multi-step, self-correcting. The agent chooses its own tools and checks its own work.

The upgrade path isn’t about complexity for its own sake — it’s about matching retrieval to the shape of the question.

Classic RAG handles “what.” Graph RAG handles “how are these related.” Agentic RAG handles “figure it out.”

Save this for your next architecture review. 📌

Which generation is your team building on right now? 👇

I said "$0 AI stack." I was wrong. 💸

The real number is ~$50/month. Here's the honest breakdown:

💰 $20/mo → GPU droplet running Llama 3.3 70B locally
💰 $20-30/mo → Frontier APIs (Claude, GPT-5) for the hard stuff
💰 $0-10/mo → Supabase, Cloudflare, Docker, Phoenix

The trick? You don't pick between frontier and local.

You ROUTE between them.

→ Frontier APIs → complex reasoning, agentic coding (10% of tasks)
→ Local models → extraction, classification, RAG (90% of tasks)
→ LangGraph or CrewAI sits in the middle and routes each request

Most teams run every task on the same tier. That's the waste.

Running classification on GPT-5 = burning money.
Running agentic coding on local Llama = burning quality.

The architect's job is matching task to tier.

$50/mo. Not $0. Not $5,000. The real number.

Save this for your next build. 🔖

—

𝗬𝗼𝘂𝗿 .𝗰𝗹𝗮𝘂𝗱𝗲/ 𝗳𝗼𝗹𝗱𝗲𝗿 𝗶𝘀𝗻'𝘁 𝗰𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻. 🧠

It's a programming model for Claude's behavior.

Most teams treat it like .env or .gitignore — a place where settings live. That's why their Claude Code stalls at "helpful sometimes."

Every folder inside is a different dimension of behavior:

→ rules/ — what Claude knows
→ commands/ — what it does
→ skills/ — how it works
→ agents/ — who it becomes
→ agent-memory/ — what it remembers
→ output-styles/ — how it communicates

Not config k***s. Orthogonal programs.

And here's what most people miss entirely 👇

There are TWO .claude/ directories, not one.

One lives in your repo — team governance. Committed, shared, stable.

One lives in ~/.claude/ — personal governance. Your rules, your shortcuts, your auto-memory that carries across every project you touch.

Most teams blur them. Personal preferences get dumped into CLAUDE.md, it balloons to 300 lines, nobody maintains it.

Most individuals never open the global one. Their Claude starts from zero in every repo.

If your Claude Code sessions feel underpowered, the gap usually isn't the model.

It's the folder.

What level is your .claude/ actually at?

—

Follow Tech Bright Tips for more on AI engineering, Claude Code, and agentic systems.

𝗪𝗵𝗮𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗵𝗮𝗽𝗽𝗲𝗻𝘀 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂 𝗰𝗮𝗹𝗹 𝗮𝗻 𝗟𝗟𝗠 𝗔𝗣𝗜

You type a prompt. ~400ms later, you get an answer.

Between those two moments: 14 infrastructure layers most developers never see.

The compressed version:

→ 𝗔𝗣𝗜 𝗚𝗮𝘁𝗲𝘄𝗮𝘆 (5ms) — where 429 errors happen
→ 𝗟𝗼𝗮𝗱 𝗕𝗮𝗹𝗮𝗻𝗰𝗲𝗿 (2ms) — why identical calls vary in speed
→ 𝗧𝗼𝗸𝗲𝗻𝗶𝘇𝗲𝗿 (3ms) — where your bill is calculated
→ 𝗠𝗼𝗱𝗲𝗹 𝗥𝗼𝘂𝘁𝗲𝗿 (1ms) — the hidden layer no one documents
→ 𝗜𝗻𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗘𝗻𝗴𝗶𝗻𝗲 (300–800ms) — 95% of your wait time
→ 𝗦𝗮𝗳𝗲𝘁𝘆 𝗖𝗹𝗮𝘀𝘀𝗶𝗳𝗶𝗲𝗿 (5ms) — can block what you've already paid for
→ 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗲 & 𝗕𝗶𝗹𝗹𝗶𝗻𝗴 (5ms) — back through the load balancer to your client
→ 𝗟𝗼𝗴𝗴𝗶𝗻𝗴 — async, feeds dashboards and capacity planning

The surprises most devs miss:

• Inference is 95% of the wait. Everything else is rounding error.
• Output tokens cost 3–5× more than input tokens.
• Streaming isn't a feature — it's a side effect of how LLMs decode.
• Prompt caching works by skipping the prefill phase entirely.
• The safety filter can reject a response you've already been charged for.

Different providers. Same 14 layers. Same physics.

Which layer surprised you the most?

Comment - 🔥 for full HD digram!

Claim it 🙏