How I Built an AI Second Brain That Processes 50 Deep-Tech Research Articles in One Afternoon
You don't have an information problem. You have an intelligence extraction problem. Here's the system I built to solve it.
I. The Drowning Phase
If you follow semiconductor and AI infrastructure research, you know the feeling.
You open SemiAnalysis. There’s a 12,000-word deep dive on AMD’s MI450X rack-scale architecture. You skim it. You highlight a few lines. You tell yourself you’ll come back to it.
You won’t.
The next day, there’s a new piece on TSMC’s N2 process node. Then one on DeepSeek’s true training costs. Then NVIDIA’s GTC announcements. Then export controls. Then datacenter cooling systems. Then AWS Trainium3. Then tariff impacts on GPU supply chains.
Each article is dense, technical, and genuinely important. Each one contains data points, forward-looking predictions, and investment implications you can’t find anywhere else. And each one disappears into the scroll the moment the next one lands.
I spent months in this cycle. I had a SemiAnalysis subscription. I read the articles. I even took notes sometimes. But when someone asked me, “What’s the current state of AMD’s software ecosystem relative to NVIDIA?” I’d fumble. I knew I’d read about it. I knew there were specific numbers. I just couldn’t retrieve them.
The problem wasn’t that I lacked information. I was drowning in it. What I lacked was a system to *extract the intelligence from the information* and make it retrievable on demand.
So I built one. In a single afternoon. Using AI.
II. Why Your Notes App Won’t Save You
Before I explain the system, let me address the false solutions -- because I tried all of them.
Highlighting and bookmarking. This is the default behavior. You highlight passages, bookmark the article, and feel productive. But highlighted text without structure is just colored noise. Six months later, you have 200 highlights across 50 articles and no way to connect them.
Manual note-taking. Better, but not scalable. A single SemiAnalysis article on AMD’s MI450X architecture runs 600+ lines with dozens of data points spanning GPU specs, software ecosystem gaps, competitive dynamics, and acquisition strategy. Manually distilling that into a useful note takes 45 minutes *per article*. Multiply by 50 articles and you’ve lost a week of your life.
AI summaries (ChatGPT, “summarize this article”). This is the most tempting and most dangerous approach. A generic AI summary strips away precisely the information that makes SemiAnalysis valuable -- the specific numbers, the non-obvious analytical insights, the investment implications. You get a paragraph that tells you “AMD is making progress on software but still lags NVIDIA” -- something you already knew. The analytical signal gets crushed into a flat summary.
What I needed wasn’t summarization. It was structured intelligence extraction -- a system that could take a 600-line technical deep-dive and produce a research note that preserves the data points, isolates the non-obvious insights, and surfaces the investment implications, all in a format that connects to every other note in my knowledge base.
III. The Intelligence Pipeline -- A System for Turning Articles into Alpha
I call the system The Intelligence Pipeline. It has three components, and the entire thing runs on two tools: Obsidian (a note-taking app that stores everything as plain markdown files) and Claude Code (Anthropic’s AI coding agent that can read files, process them, and write structured output).
Here’s the architecture:
RAW INPUT PROCESSING ENGINE STRUCTURED OUTPUT
───────── ───────────────── ─────────────────
Obsidian Claude Code AI Research Notes
Web Clipper ───> + Processing Prompt ──> in Obsidian
(50 articles) (format spec) (50 notes)
Layer 1: Capture. Obsidian Web Clipper saves full SemiAnalysis articles as markdown files into a “Clippings/” folder. No formatting loss. No paywall issues. Raw, complete articles preserved as plain text.
Layer 2: Process. Claude Code reads every clipping and transforms it through a structured processing prompt -- a precise specification that tells the AI exactly what to extract and how to format it.
Layer 3: Connect. The output goes into a “reports/” folder as structured Obsidian notes with YAML frontmatter, wikilinks, and standardized sections. Every company, concept, and person becomes a clickable link in your knowledge graph.
The magic is in Layer 2 -- the processing prompt. That’s where the intelligence extraction happens. Everything else is just plumbing.
IV. The Processing Prompt -- Where Intelligence Extraction Happens
The processing prompt is a one-page specification that tells the AI exactly what to extract from each article. It’s the most important component of the system, and getting it right took several iterations.
Here’s what it produces for every article:
1. YAML Frontmatter (The Metadata Layer)
Every note starts with structured metadata: title, source URL, author, publication date, sector, and -- critically -- three linked fields:
Companies: Every company mentioned, as a wikilink. "[[AMD]]", "[[NVIDIA]]", "[[TSMC]]", "[[DeepSeek]]". Concepts: Every technical concept, as a wikilink. "[[ROCm]]", "[[CUDA]]", "[[Jevons Paradox]]", "[[HBM]]", "[[Rack-Scale AI]]". Tags: Searchable labels. "gpu-competition", "export-controls", "inference-pricing".
This metadata layer is what makes the system compound over time. After processing 50 articles, I don’t just have 50 notes -- I have a *graph* where clicking “[[NVIDIA]]” shows me every article that discusses NVIDIA, clicking “[[KV Cache]]” shows me every article where KV cache optimizations matter, and clicking “[[Dylan Patel]]” shows me every analysis by tat author.
2. Thesis (The 30-Second Brief)
Three sentences maximum. What is the core claim, what makes it unique, what are the implications. This is the section you read when someone asks “What did SemiAnalysis say about DeepSeek?” and you need an answer in 30 seconds.
Example from my DeepSeek note:
DeepSeek is a genuinely impressive fast-follower lab whose true training costs are far higher than the viral $6M figure, with total hardware spend exceeding $500M and server CapEx around $1.6B. The panic narrative that efficiency gains eliminate demand for compute is contradicted by Jevons Paradox dynamics already visible in soaring Nvidia H100 spot prices, and the real structural impact is margin compression on closed-model providers like OpenAI, not reduced GPU demand. Export Controls did not fail but rather came too late to prevent stockpiling, and future restrictions on the H20 will increasingly constrain DeepSeek’s scaling trajectory relative to US labs.
Three sentences. The entire analytical signal of a dense technical article.
3. Key Data Points (The Lookup Table)
Bulleted. Specific numbers, metrics, forecasts -- things you’d look up again. The kind of information that wins arguments and anchors investment theses.
Examples:
DeepSeek GPU fleet: ~50,000 Hopper GPUs total; includes ~10,000 H800s, ~10,000 H100s
True hardware spend. >$500M over company history; $6M covers only pre-training GPU cost for V3
MLA KV Cache reduction: ~93.3% reduction per query versus standard attention
Bank of China AI subsidy: $140B (1 Trillion Yuan) over 5 years
These are the numbers that vanish from your memory within a week of reading the original article. Now they’re permanently indexed and retrievable.
4. Key Insights (The Non-Obvious Analysis)
This is the highest-value section. Not summaries -- *analytical reasoning* that the AI extracts from the article’s deeper arguments. Each insight gets a bold title and a 2-3 sentence explanation.
Example:
The $6M figure is a misleading BOM line item, not total cost. The viral $6M training cost attributed to DeepSeek V3 covers only the GPU hours for the pre-training run itself. It excludes R&D, architecture experimentation (e.g., Multi-Head Latent Attention took months of dedicated team effort), ablation studies, data curation, synthetic data generation for R1, and total cost of ownership. The same logic would make Anthropic’s Claude 3.5 Sonnet look like it cost only tens of millions when the company has raised tens of billions.
This is intelligence you can deploy in a conversation. It’s the kind of insight that separates someone who “read about DeepSeek” from someone who *understands* DeepSeek.
5. Forward-Looking Predictions (The Crystal Ball)
Bulleted. Specific claims about the future with explicit timeframes. These are the testable predictions that make a research note appreciating over time rather than depreciating.
6. Investment Implications (The Action Layer)
Organized under three subheadings: Bullish, Bearish, Watch. Each entry: bold company wikilink + 1-2 sentence reasoning.
This section is what makes the system useful beyond pure intellectual exercise. Every note ends with actionable investment implications, tagged to specific companies, with clear reasoning.
V. The Transformation -- Before and After
Here’s what the system actually does to a real article.
Before (Raw Clipping): A 617-line SemiAnalysis article on AMD’s MI450X architecture. Dense paragraphs mixing executive summary points, Lisa Su meeting details, compensation analysis, Python DSL comparisons, rack-scale hardware specs, and forward-looking product roadmaps. Valuable, but impossible to scan.
After (Processed Research Note): A ~130-line structured note with:
17 companies wikilinked (AMD, NVIDIA, Microsoft, OpenAI, Oracle, Google, Meta, xAI, Tesla, Broadcom, Astera Labs, ZT Systems, Quanta, Foxconn, Celestica, Lenovo, Huawei)
19 concepts wikilinked (ROCm, CUDA, NCCL, NVLink, PyTorch, Triton, UALink, HBM, Rack-Scale AI, Python DSL...)
21 specific data points (GPU cluster sizes, compensation gaps, bandwidth specs, TCO comparisons)
7 non-obvious insights (compensation benchmarking as the real bottleneck, Python ecosystem as NVIDIA’s true new moat, UALink effectively dead for H2 2026)
Timeline-specific predictions
Bullish/Bearish/Watch investment implications for individual companies
A 617-line wall of text became a structured intelligence asset. And it took the AI about 60 seconds.
VI. The Build Protocol -- How to Set This Up
Here’s exactly what I did, step by step.
Step 1: Set Up the Capture Layer
Install Obsidian. Install the Obsidian Web Clipper browser extension. Configure it to save clippings as markdown into a “Clippings/” folder inside your vault. Clip your articles. I clipped 50 SemiAnalysis articles spanning January 2025 to February 2026 -- covering export controls, chip architecture, datacenter infrastructure, AI training economics, and GPU competition.
Step 2: Write the Processing Prompt
This is the critical step. Create a file called “_processing-prompt.md” in your “reports/” folder. This file is the instruction set for the AI. It specifies:
The exact YAML frontmatter structure (with rules for wikilink quoting, block list format, no inline arrays)
The six sections: Thesis, Key Data Points, Key Insights, Forward-Looking Predictions, Investment Implications
Length constraints (150-250 lines per note)
Quality rules (extract analytical signal, don’t paraphrase, use wikilinks for all entities)
The processing prompt is your editorial voice encoded as a specification. It determines what the AI pays attention to and what it ignores. Get this right and the output is consistently excellent. Get it wrong and you get generic summaries.
Step 3: Run the Processing Engine
Open Claude Code in your vault directory. Point it at the processing prompt and the clippings folder. Let it read each article, apply the specification, and generate the structured notes.
For 50 articles, the entire processing run takes an afternoon. Each note takes about 60-90 seconds. The AI reads the full article, identifies companies and concepts, extracts data points, isolates non-obvious insights, generates predictions, and formats investment implications -- all following the processing prompt specification.
Step 4: Verify and Refine
Spot-check the output. The first few notes may reveal gaps in your processing prompt -- maybe it’s missing a section you care about, or the thesis length isn’t right, or the data points aren’t specific enough. Iterate on the prompt. Re-run the notes that need improvement.
After one round of refinement, I had 50 structured research notes covering the entire SemiAnalysis output from the past year. Every note interlinked. Every company and concept clickable. Every data point indexed.
VII. What Changes When You Have a Second Brain
The transformation isn’t just organizational. It changes how you think about the sector.
Retrieval becomes instant. Someone mentions TSMC N2 in conversation. You open Obsidian, click [[TSMC]], and see every article that discusses TSMC -- with thesis statements, data points, and investment implications already extracted. You’re not searching your memory. You’re querying a knowledge graph.
Connections become visible. When you click [[KV Cache]], you see it mentioned in the DeepSeek article (MLA’s 93.3% reduction), the AMD article (MI450X’s 4-tier memory hierarchy for cache tiering), and the inference benchmark article. Patterns that were invisible when the information was scattered across 50 separate readings become obvious when they’re linked in a graph.
Investment thinking compounds. Every note ends with Bullish/Bearish/Watch implications. After 50 notes, you don’t just have 50 separate investment views -- you have a multi-source, cross-referenced investment thesis that strengthens or weakens as new data arrives. When a new SemiAnalysis article drops, you process it, and its implications automatically connect to everything you’ve already built.
Your reading becomes non-linear. Instead of reading articles sequentially as they publish, you can now navigate by company, by concept, by time period, or by investment implication. Want to understand AMD’s trajectory? Follow the [[AMD]] link through every article. Want to understand the inference cost curve? Follow [[Inference Cost Deflation]] across multiple analyses.
VIII. The System Behind the System
There’s a meta-insight here that goes beyond semiconductor research.
The traditional approach to knowledge work is: read, highlight, forget, re-read. The AI-augmented approach is: capture, process, structure, connect. The difference is that the second approach produces a compounding asset rather than a depreciating memory.
Every note I add makes every other note more valuable -- because it creates new connections in the graph. The 50th note is more valuable than the 1st note, not because the article was better, but because it connects to 49 other structured analyses.
This is what I call The Intelligence Compound Effect: the value of your knowledge base grows non-linearly with every new input, because each input creates connections to everything that came before.
And here’s the part that matters most: the bottleneck is no longer processing capacity. AI handles that. The bottleneck is now editorial judgment -- choosing what to read, how to structure the extraction, and what connections to pursue. The processing prompt is where your expertise lives. The AI is the engine. You’re the architect.
IX. Start Here
If you’ve read this far, you’re probably thinking about what domain you’d build this for. Here’s the minimum viable version:
Pick your 10 highest-signal sources. Newsletters, research reports, earnings transcripts -- whatever contains the raw intelligence for your domain.
Write a one-page processing prompt. Define the sections. Define what “insight” means in your context. Define the metadata structure that will power your graph.
Process 10 articles. Not 50. Ten. See what the output looks like. Refine the prompt.
Use the output for one real decision. Answer a question, write an analysis, make an investment call. The system proves its value the first time you retrieve something you would have otherwise forgotten.
The people who will have an information advantage in the next few years aren’t the ones who read the most. They’re the ones who built systems to extract, structure, and compound the intelligence from what they read.
The tools exist. The articles exist. The only question is whether you’ll build the pipeline -- or keep drowning in the scroll.