Val retweeted
Open the prompt
Cmd A
Open Claude Opus 5.5
Cmd V
Enter "Build 24/7 AI Hedge Fund"
WIN
Val retweeted
Azure is becoming the operating system for enterprise AI.
It is no longer only about hosting models or adding a chatbot to an existing application. Azure AI Foundry brings the full AI development lifecycle into one connected ecosystem.
From choosing the right model to deploying agents, monitoring performance, and securing production workloads, every layer can work together.
The ecosystem is built around four key areas:
1. Design with the best models
Teams can access Azure OpenAI, Phi, DeepSeek, Meta Llama, Mistral, Cohere, Hugging Face, Nvidia, Databricks, Snowflake, and other model providers.
2. Customize with an agent toolchain
Developers can connect agents with Azure AI Search, Fabric, SQL, Cosmos DB, Functions, Kubernetes, Semantic Kernel, LangChain, LlamaIndex, AutoGen, and many other services.
3. Manage production performance
Azure Monitor, App Configuration, Microsoft Cost Management, ClearML, Dataloop, and GitHub Actions help teams observe, optimize, and improve AI systems.
4. Safeguard with trustworthy AI
Content Safety, Microsoft Defender, Entra ID, Azure Policy, Confidential Computing, Backup, and Application Gateway support more secure and governed deployments.
Copilot Studio, Visual Studio, GitHub, and the Azure AI Foundry SDK connect the entire development experience.
The real advantage is not access to more tools.
It is having one ecosystem that supports AI from the first prototype to secure production.
Save this if you are building AI agents on Azure.
𝗕𝗲𝗰𝗼𝗺𝗲 𝗯𝗲𝘁𝘁𝗲𝗿 𝗮𝘁 𝗔𝗜 𝗶𝗻 𝗷𝘂𝘀𝘁 𝟭 𝗺𝗶𝗻𝘂𝘁𝗲 𝗮 𝗱𝗮𝘆. 𝗝𝗼𝗶𝗻 𝗺𝘆 𝘄𝗲𝗲𝗸𝗹𝘆 𝗻𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿 𝘄𝗵𝗲𝗿𝗲 𝗜 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁 𝘁𝗵𝗲 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗷𝗼𝘂𝗿𝗻𝗲𝘆 𝗼𝗳 𝗔𝗜 𝘁𝗿𝗮𝗻𝘀𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻.
👉 𝗦𝗶𝗴𝗻 𝘂𝗽 𝗳𝗿𝗲𝗲 now → avsl.beehiiv.com/
Follow @AiswaryaVenkit1 for more such insights!!
Val retweeted
Most developers treat CLAUDE.md like documentation.
That’s the mistake.
It’s not a README.
It’s the control layer for your AI agent.
If your outputs feel inconsistent, buggy, or “random”…
the problem usually isn’t the model.
It’s the instruction architecture.
The biggest unlock is understanding scope hierarchy:
• Global scope → coding standards, universal behavior
• Project scope → stack, workflows, commands
• Folder scope → local overrides for specific tasks
And yes:
the nearest scope overrides everything above it.
Another game-changing framework:
WHAT → project context
WHY → engineering principles & constraints
HOW → execution rules & commands
Miss one layer and the agent starts guessing.
Specificity is what separates reliable agents from chaotic ones.
❌ “Write production-ready code”
✅ “Use TypeScript strict mode, Zod validation, and async error boundaries”
❌ “Add tests”
✅ “Write Vitest unit tests with 80%+ coverage”
A few rules that dramatically improve agent performance:
Start with /init before customization
Keep CLAUDE.md concise (<500 lines)
Use hooks for repeatable behaviors
Treat it like living infrastructure
Reference configs instead of duplicating logic
The uncomfortable truth:
Most AI agents don’t fail because the model is weak.
They fail because the operating instructions are incomplete.
Better system design = better AI behavior.
The engineers who understand this early will build agents that actually scale. 🚀
📌 Save this (you’ll need it when scaling agents)
♻️ Share with a dev building with AI
➕ Follow for no-fluff AI systems & workflows 🚀
Val retweeted
Claude Code becomes much more powerful when your project is structured for it.
☑︎ CLAUDE.md
☑︎ Skills + Hooks
☑︎ MCP
☑︎ Subagents
☑︎ Agent Teams
☑︎ Slash Commands
☑︎ Automated workflows
Don’t just use AI to code.
Build with AI.
#ClaudeCode #AI #LLM
Val retweeted
Stop treating GPT-6 Astra like a regular chatbot.
Seriously.
It uses your computer, carries the task, and checks its own work.
Here is exactly how it works:
Here is the best version of my Content:
What I (actually) try every day → lnkd.in/dEQTp_uh
60+ Deep dives that only 1% read → lnkd.in/g5Y6UVup
☑ 1. Why Astra Changes Everything
→ Astra uses your computer instead of just answering.
→ It carries the task from start to full finish.
→ It checks its own work before shipping the result.
☑ 2. What Astra Can Actually Do
→ It navigates websites, apps, and internal tools.
→ It traces bugs, writes fixes, and runs your tests.
→ It researches the web then builds your docs.
↳ Docs, sheets, decks, and full websites, from brief.
☑ 3. The Astra Workflow
→ You give it a brief with goals and context.
→ It plans every step, then picks the right tools.
→ It ships the finished file and keeps working after.
☑ 4. Connect Everything
→ Astra connects to GitHub, Notion, Slack, and Figma.
→ MCP links Astra directly to any custom tool.
→ One connector puts Astra inside your entire stack.
☑ 5. Essential Controls
→ You set reasoning effort from low up to max.
→ Higher effort handles coding and hard multi-step tasks.
→ Choose gpt-6-astra to handle the full end-to-end workload.
☑ 6. Briefs & Project Memory
→ You paste your brief straight into a ChatGPT project.
→ Project memory keeps goals, limits, and sources saved.
→ Every new task opens already loaded with your context.
☑ 7. Prompting Techniques
→ Give Astra a full brief instead of one question.
→ Always ask it to verify before you ship anything.
→ Attach your exact template so the output matches.
Save this post. You'll want it later.
For more AI workflow breakdowns like this: 👇
→ Go to substack.com/@humzakhalid
→ Subscribe to my free newsletter (don't pay anything)
→ Get more free and daily cheatsheets, guides, and prompts
♻️ Repost to share it with your network.
Val retweeted
Most Claude users treat every new chat as a blank slate, and projects exist specifically to stop that. A project is memory, a workspace, and scoped context all in one place, so work you did last week is still there when you open it again.
That comes from four things happening at once. Claude retains what happened during earlier work inside that project. Instructions, files, and finished outputs all stay in one place instead of scattered across chats. A Cowork-based project can reach local files and run on a set schedule instead of staying purely conversational. And memory stays scoped to each project, so separate lines of work never bleed into each other.
Setting one up is five steps. Create the project, starting from scratch, bringing over an existing chat, or attaching a folder already in use. Add project instructions defining the goal, preferred terminology, analytical approach, and any rules Claude should follow. Add context by uploading reference documents, transcripts, PDFs, and folders. Run work inside the project, and every session adds to its memory, carried forward into the next task automatically. Then stack it with skills, since projects hold ongoing context while skills handle the repeatable, formatted work on top of it.
Projects and skills are not competing for the same job. A skill packages the steps for one recurring job so Claude runs it the same way every time. A project is a workspace built for work that continues over time. Use a project when the task depends on memory of earlier work, and know that a chat project supports planning while a Cowork project carries that same context into actual execution. A helpful folder setup inside one looks like /reference, /analysis, /deliverables, kept separate instead of dumped together.
Underneath all of it is a context stack, ordered from broadest to most specific: global instructions, context files, project instructions and files, skills, then the prompt itself. A workspace with memory beats a prompt with no context, every single time.
Credit to Alex Banks at The Signal and the Claude docs for this breakdown.
Bookmark this before your next Claude conversation starts from zero again.
Val retweeted
CLAUDE + OBSIDIAN + LOOP ENGINEERING = A VAULT THAT RUNS ITSELF
the core idea: the vault is the loop's state, not the chat window
every single thing Claude knows sits in a .md file
the loop:
> capture - a thought drops into 00-inbox
> context - Claude Opus 5 gathers links, tags and the notes sitting next to it
> draft - edits happen inside a git worktree, the live vault stays untouched
> review - a critic agent reads the diff before anything ships
> commit - appended to the vault, nothing gets rewritten
the key insight: frontmatter fields like supports, contradicts and supersedes work as graph edges rather than metadata - the note format is the write API
begin with a plain loop. it costs roughly 2-4x a single direct call
> move to a full graph only once state has to survive past the session, several agents need to coordinate, or you have to explain what changed - that step can run 10-50x
one review assistant climbed 55% -> 72% -> 84% by walking through these shapes in order
worth stealing even if you never build a graph: the review step
most vaults leave it out and let claude write straight into live notes
mistakes pile up unnoticed for months
put that gate in before anything else
I looked at Karpathy's diagram for the third time before I understood why 16 million people stopped scrolling for a picture of three folders, and the answer made me feel stupid
5,000 stars. 16 million views. for something that looks, at a glance, like nothing more than a filing system
that's not what stopped them. it's the sentence underneath it that nobody screenshots, the one that actually explains why your AI resets every single morning: retrieval answers questions, compilation builds understanding
a filing cabinet holds notes. you search when you need something. it gets bigger every single year and understands exactly as much on day one thousand as it did on day one. that's not memory. that's just accumulation wearing memory's clothes
a compiled wiki does something the filing cabinet structurally cannot. raw holds the source, untouched, forever. the model reads it once, connects it to everything already compiled, and files the synthesis permanently. the human reads it. the model writes it. every question after that isn't a search anymore. it's a lookup inside something that's been getting smarter while you did absolutely nothing
one file sits at the center of it and does something no folder in that diagram gets credit for. CLAUDE.md. who you are, what you're working on, what you've already tried. the model reads it before every single session, automatically, so you stop explaining yourself to a machine that was supposed to already know you by now
almost none of the 16 million who saw the diagram went and built it. the ones who did stopped resetting every morning and started compounding every single day, and they never once went back to the folder they used to proudly call "my notes"
full architecture below. build the compiler. never touch the cabinet again
i'm leaking my entire coding agent setup...
20 billion tokens and 12,000 sessions later, i got sick of explaining the same project every time i switched tools.
so i built them a shared brain
steal the prompt
[start prompt]
Set up Agentic Stack as my local second brain and LLM-maintained wiki, shared across the supported coding tools I have installed.
Carry this through installation, connection, source selection, wiki creation, and real cross-tool verification. Use the structure below as a proposed design, adapting it to the capabilities you actually verify.
1. Research the supported setup
Read these primary sources before making changes:
github.com/codejunkie99/agen…
github.com/codejunkie99/agen…
gist.github.com/karpathy/442…
Check the current documentation against the installed version. Clearly distinguish Agentic Stack’s existing features from additional wiki workflows you create.
Do not invent commands, APIs, integrations, export formats, or automatic synchronization behavior.
2. Inspect my environment and preserve existing work
Identify:
Installed supported coding tools and their versions.
Existing Agentic Stack installation and configuration.
Relevant projects and available conversation history.
Existing skills, rules, memory files, and MCP connections.
A suitable location for the shared wiki.
Before editing configurations, record the intended changes and create recoverable backups. Preserve unrelated settings, customized instructions, credentials, source conversations, and existing projects.
Keep backups private and outside version control. Never print secrets or copy provider credentials between tools.
3. Install and connect Agentic Stack
Use the documented installation method for my platform.
Connect the supported tools I have installed through the appropriate documented mechanisms. Preserve existing MCP entries and tool-specific settings. Restart or reload tools where required.
Verify each connection through an actual tool invocation. Distinguish these states:
Detected.
Configured.
Requires restart or authentication.
Retrieval verified.
Blocked or unsupported.
Do not claim a connection works merely because an installer completed or a toggle is enabled.
4. Help me select the first sources
Inventory candidate sources without importing everything automatically.
Recommend a bounded first import from one active project, prioritizing:
Conversations containing meaningful decisions.
Architecture explanations and project documentation.
Verified debugging lessons.
Repeatable workflows.
Explicit preferences and conventions.
Relevant skills and rules.
Show me the proposed sources and ask me to select what to include before importing private content. Record the approved scope so you can reuse that authorization for subsequent refreshes.
Exclude credentials, hidden reasoning, unrelated personal information, dependency folders, generated files, and unnecessary tool output.
5. Create a portable wiki directory
Create a separate SecondBrain/ directory at a suitable location. Keep it outside application bundles and native conversation stores.
Use this structure, creating content folders only when needed:
SecondBrain/
├── README.md
├── AGENTS.md
├── config/
│ ├── sources.yaml
│ ├── projects.yaml
│ ├── routing.yaml
│ ├── policy.md
│ └── integrations.md
├── inbox/
├── raw/
│ ├── conversations/
│ ├── documents/
│ └── web/
├── catalog/
│ ├── sources.jsonl
│ ├── pages.jsonl
│ └── exclusions.jsonl
├── wiki/
│ ├── index.md
│ ├── projects/
│ ├── decisions/
│ ├── concepts/
│ ├── workflows/
│ ├── lessons/
│ ├── research/
│ ├── sources/
│ ├── preferences/
│ ├── skills/
│ └── rules/
├── templates/
├── operations/
│ ├── ingest.md
│ ├── query.md
│ ├── maintain.md
│ └── restore.md
├── staging/
├── reports/
├── logs/
├── exports/
└── .runtime/
Explain each directory in README.md.
Use AGENTS.md as the shared wiki operating contract. Add tool-specific pointers only where necessary, preserving existing instruction files.
Treat these files as our wiki configuration, not as undocumented Agentic Stack configuration formats.
6. Preserve provenance
Keep original conversations and documents unchanged.
For each approved source, record:
Stable source ID.
Tool or provider.
Project and scope.
Original path, URL, or retrieval locator.
Conversation ID and message range where available.
Source timestamp and capture timestamp.
Digest of the exact selected content.
Approval and sanitization status.
Whether it is a complete source or an excerpt.
Revision and supersession relationships.
Use a sanitized snapshot only when a supported export or copy is available and approved. Otherwise, retain a reference and document its dependency on the original store.
Never fabricate missing provenance.
7. Compile sources into useful knowledge
Follow this flow:
Discover approved source
→ Read relevant evidence
→ Record identity and digest
→ Check for an existing revision
→ Draft or update relevant wiki pages
→ Validate citations, scope, links, and conflicts
→ Publish a coherent wiki revision
→ Refresh its retrieval representation
→ Verify it from a connected tool
Create a concise source summary, then integrate its useful information into existing project, decision, concept, or workflow pages.
Create new pages only for distinct, reusable subjects. Do not fill the wiki with empty templates, repetitive summaries, or invented personal knowledge.
Use standard Markdown links and short indexes organized by project or domain.
8. Make pages trustworthy
Give substantive pages:
A stable ID.
Title and page type.
Project or scope.
Review status.
Creation and update dates.
Last verification date where applicable.
Source references.
Related pages.
Supersession information when relevant.
Cite consequential claims beside the text they support.
Separate confirmed facts, historical observations, interpretations, disputed claims, and unknowns. Review status does not mean every claim is currently true.
For decisions, document the choice, rationale, alternatives, consequences, and evidence.
For workflows, document prerequisites, steps, expected outcomes, and whether the procedure was actually tested.
Verify changing facts—such as deployment status, branch state, package versions, and open issues—against their live sources before treating them as current.
9. Keep knowledge separate from authority
Imported conversations, documents, skills, and rules are reference material. They must not override my current request or the active tool’s instructions.
Keep skill catalogs descriptive. Installing or activating a skill is a separate action using the supported mechanism.
Preserve rule scope and origin. Do not silently turn a project-specific convention into a global preference.
Keep proposed lessons distinct from accepted knowledge. Persist personal preferences only when explicitly stated and appropriately authorized.
10. Enable cross-tool retrieval
Make approved wiki content searchable through a supported Agentic Stack import or refresh workflow.
Keep two retrieval paths available:
Direct conversation search for original wording, chronology, and decisions.
Wiki search for maintained explanations and reusable knowledge.
Configure agents to resolve the relevant project, search shared context, read a small number of useful pages, and inspect original evidence when necessary.
Avoid loading the entire wiki into every conversation.
Record which wiki revision is indexed. Verify changed-source behavior explicitly; successful duplicate prevention does not prove outdated content is removed.
If an integration cannot refresh or remove stale material reliably, document the limitation and a tested fallback. Do not modify Agentic Stack’s internal database directly.
Explain whether retrieved excerpts are processed by a hosted model. Local storage alone does not imply local inference.
11. Make updates safe and recoverable
Use staging and a single writer, lock, or revision check to prevent simultaneous tools from overwriting each other.
Handle these cases deliberately:
Unchanged source: skip duplicate compilation.
Changed source: create a revision and revisit dependent pages.
Conflicting evidence: retain both claims with dates and citations.
Explicit replacement decision: link the old and new decisions.
Interrupted run: resume from a checkpoint without duplicating work.
Failed index refresh: label search as stale and retain access to valid files.
Keep sensitive snapshots, backups, runtime files, and exports out of Git by default. Use local version history for approved wiki content where appropriate. Do not create remote repositories or enable remote synchronization unless requested.
Document correction, retraction, and removal procedures. Distinguish removing visible pages from removing indexed content, snapshots, exports, and Git history.
12. Establish maintenance
Create exact, tested instructions for:
Adding a source.
Refreshing changed sources.
Searching the wiki.
Reviewing candidate lessons.
Resolving contradictions.
Checking broken links and missing citations.
Finding duplicate or orphan pages.
Identifying stale claims.
Restoring files and configuration.
Start with an explicit manual maintenance workflow. Do not claim background maintenance is running unless a scheduler has actually been configured and tested within my authorization.
After meaningful work, propose small sourced updates for decisions and verified lessons.
13. Verify real continuity
Run an end-to-end demonstration:
From one coding tool, find a real approved conversation originating in another.
Show its source tool, identity, date, and relevant evidence.
Retrieve the related wiki page.
Explain the decision or context recovered.
Inspect the current project state.
Use the recovered context to propose or perform the next authorized step.
Describe this accurately as cross-tool context retrieval, not migration of the original live session.
Also verify:
Repeated imports do not create duplicate logical content.
Changed evidence updates the correct page and retrieval result.
Citations and page links resolve.
Excluded synthetic material stays outside the tested import route.
Conflicting synthetic evidence remains visibly disputed.
Original sources and unrelated configurations remain intact.
A changed wiki file and configuration backup can be recovered.
Use synthetic fixtures where testing could damage real knowledge.
14. Give me a concrete handoff
Finish with:
Installed versions and actual storage paths.
A connection-status table for each tool.
Approved and imported sources.
Created wiki pages and their purpose.
The published and indexed wiki revisions.
Verification results with evidence.
Known limitations and remaining setup.
Exact tested instructions for daily use and recovery.
Continue through the authorized work. Ask only when source selection, missing credentials, or a consequential decision requires my input. Report blockers precisely, and never present installation alone as a completed second brain.
[end prompt]
"what the F*CK is github"
probably what you were thinking when you started vibe-coding and needed to back your work up
took me months to figure all the nerd terminology out enough to use it with developers so here's it all explained so a business owner like YOU can prevent AI from messing up your hard work in one prompt
00:00 Git is Your Undo Button
02:48 Repository, Commit, and Push
05:33 Pull, Main, Branch, and Merge
08:18 Pull Requests and Work Trees
10:27 How to Set Up GitHub
11:26 Mid-video CTA
12:43 Branches in Action
14:52 Vercel Preview URLs
16:30 Let Your AI Handle Git
Val retweeted
Some guy built a free AI university on GitHub.
Not tutorials.
Not theory.
Full real-world AI systems.
Step by step.
Week 1 → Docker, FastAPI, databases
Week 2 → Automated data pipelines
Week 3 → Build your own search engine (BM25)
Week 4 → Hybrid search (semantic + keyword)
Week 5 → Full RAG system
Week 6 → Production-ready (caching + monitoring)
Week 7 → Agentic AI with LangGraph
You don’t just “learn AI”.
You ship it.
GitHub (free): github.com/jamwithai/product…
🚨 P.S. Want to learn how to build + ship AI and Data Science projects (that businesses actually want in 2026)?
I am hosting a free workshop to help you get started with AI + DS projects in Python.
Register here (500 seats): learn.business-science.io/ai…
Val retweeted
You installed Claude Code.
And then probably stared at the terminal wondering:
“Okay… what do I actually tell it?”
Anthropic has quietly published a library of 52 official Claude Code prompts ↓
Not random prompts from X.
Actual prompts from Claude Code’s docs, covering real workflows:
BUILD → Implement a feature
→ Refactor code
→ Find bugs
→ Write tests
→ Review changes
UNDERSTAND → Explain unfamiliar code
→ Trace how code evolved
→ Find where a function is used
→ Ask codebase questions
PLAN → Plan before touching code
→ Turn meeting notes into tickets
→ Map dependencies
PROTOTYPE → Turn a mockup into a working prototype
→ Implement from screenshots
REVIEW → Review changes before committing
→ Find regressions
→ Investigate failing tests
And it goes beyond coding:
DATA AUTOMATE RELEASE GIT DEBUG INCIDENTS
The best part?
21 of the 52 prompts are tagged for non-engineers.
So you don't need to be a senior developer to get value from Claude Code.
This is basically a cheat sheet for talking to Claude Code properly.
Save this:
52 prompts → 15 categories → 5 stages
If you use Claude Code, this belongs in your bookmarks.
Repost ♻️ so someone else stops prompting Claude Code like a chatbot.
Should you skip, read, or study these books if you're a young entrepreneur? youtube.com/shorts/72DxhqI_5… via @YouTube
F*ck, this setup turns Grok into a 7-agent council instead of one chatbot, and it's too good.
The main thing is that it costs $0 per month, it runs locally, only WiFi needed,
This used to be one prompt doing everything, research, writing, editing, fact-checking, all mixed into one messy call.
Now one agent just researches, pulls facts and reads the source before anyone else touches it.
Another writes three hook variants, then a separate critic agent kills the weak ones immediately.
One checks every number for accuracy before it goes anywhere, one reshapes the whole thing into the exact format needed.
And one merges everything into a single final output, each step its own API call, its own system prompt, sometimes even its own model.
You’re Not Behind (Yet): How to Build Your First AI Agent (Full Guide) youtu.be/Bm84BAtOfQw?is=P8g8… via @YouTube
Val retweeted
DeepSeek open sourced their agent harness, and five patterns in it are worth stealing regardless of which model you run.
Every model request gets derived from one append-only event log instead of a growing context blob. Log becomes context, not the other way around, so nothing drifts silently between turns.
Repeat calls at 3, 5, and 8 attempts get a reminder instead of a hard stop. The model keeps control of the loop, and you get a soft breaker instead of a wall it has to work around.
Tool output gets shown honestly. If a call returns 4,000 results, the agent sees 100 sampled fairly, but the full result still gets saved to disk instead of thrown away. The model never has to pretend it saw everything.
Code-run tool calls go through the exact same permission checks as every other tool call. There is no faster path that skips the policy layer just because the call came from generated code.
Every round starts with a clean context. Only files and a small handoff carry forward to the next one, so the context can die without the work dying with it.
Build for this and you get agents that are easier to debug, safer to run, and cheaper to restart when something breaks.
Bookmark this before you write your next agent harness from scratch.
Patrick Bet-David Ranks His Favorite Books youtube.com/shorts/UksVaylvf… via @YouTube
Alternative Spring Break at El Monte County Park tockify.com/sdparkscalendar/…
