# Building an AI-Powered Research Management System: From Chaos to Clarity **Author:** Prof. Dr. Sigurd Schacht **Date:** January 2026 **Reading Time:** 15-20 minutes ![[Gemini_Generated_Image_p1k2vep1k2vep1k2.png]] ## The Problem Every Researcher Faces If you're a researcher, you know this feeling: You have 47 browser tabs open with promising papers. A notebook full of half-formed ideas. Sticky notes on your monitor. Ideas scattered across Notion, Markdown files, email drafts, and voice memos. Some ideas are brilliant. Most will be forgotten. The cost of this chaos is enormous: - **Ideas die in the inbox.** That spark you had at 2 AM? Buried under newer sparks. - **Context switching kills depth.** Jumping between five "active" projects means none get your best thinking. - **Shipping is hard.** Without structure, projects linger at 80% forever. - **Mission drift happens.** Without alignment checks, you work on whatever feels urgent, not what matters. I built a system to solve this. It combines Obsidian for note-taking, structured templates for thinking, and **Claude Code** (Anthropic's AI coding assistant) for automation. After using it, I believe it works. Ideas should flow from capture to publication. Focus is maintained. Output should increase. I will update these claims after a month of use. This post will teach you exactly how to build this system yourself. ## The Core Philosophy: Focus Through Structure Before diving into implementation, let's establish the principles: ### Principle 1: One Active Project This is non-negotiable. At any moment, you should have **exactly one project** in active development. Not two. Not "one main project plus a small side thing." One. Why? Because context switching destroys creative work. Every time you switch projects, you lose 20-30 minutes rebuilding mental context. Research requires deep thinking, and deep thinking requires sustained attention. "But I have multiple deadlines!" Yes. Your backlog handles that. Ideas wait their turn, fully documented, ready to activate when the current project ships. ### Principle 2: Structured Thinking Forces Clarity Every research idea becomes a **one-pager** before any work begins. This one-pager follows a strict template that forces you to answer: - What's the research question? - What gap does this fill? - How will you do it? - What will you produce? - How does it align with your mission? If you can't fill out the one-pager, you don't understand the idea well enough to work on it. The template isn't bureaucracy—it's a clarity machine. ### Principle 3: Alignment Beats Opportunity Not every good idea is the right idea for you. I work at COAI Research Institute, which focuses on Human-Compatible AI across three pillars: Agent Behavior, Interpretability, and AI Safety. Every idea I process gets evaluated against these pillars. You should define your own pillars—maybe they're your PhD thesis themes, your lab's focus areas, or your career goals. The point is: every idea must pass an alignment check before entering the backlog. ### Principle 4: Ship or Park—No Limbo Projects either get completed ("shipped") or explicitly paused ("parked") with documented reasons. There's no limbo state where projects slowly die of neglect. This forces honest decisions: "Is this worth finishing?" If yes, finish it. If no, park it and move on. ## The Folder Structure The system lives in a single folder (I call it `/Research`) with this structure: ``` /Research ├── CLAUDE.md ← Instructions for Claude Code ├── _Research-Overview.md ← UNIFIED DASHBOARD (backlog + supervised + active) ├── _Template-Research-Idea.md ← One-pager template ├── _Template-Meeting.md ← Meeting notes template ├── _Template-Progress-Log.md ← Progress tracking template │ ├── 0-Inbox/ ← Raw ideas, messy notes │ └── (drop anything here) │ ├── 1-Active/ ← ONE active project only (your focus) │ └── {Project-Name}/ │ ├── {Project-Name}.md ← One-pager (status: active) │ ├── README.md ← Project overview │ ├── drafts/ ← Paper drafts │ ├── figures/ ← Diagrams, plots │ ├── notes/ ← Meetings, ideas │ └── literature/ ← Related papers │ ├── 1-Supervised/ ← Student-assigned projects (multiple) │ └── {Project-Name}/ │ ├── {Project-Name}.md ← One-pager with Dataview dashboard │ ├── Progress-Log.md ← Dated progress entries │ └── Meetings/ ← Supervision meeting notes │ ├── 2-Backlog/ ← Structured one-pagers (UNASSIGNED only) │ ├── _Projects/ ← Project hubs (multi-paper series) │ ├── infographics/ ← Generated visual summaries │ └── *.md ← Research one-pagers │ ├── 3-Archive/ ← Completed or parked │ ├── Archived-Ideas/ ← Processed inbox ideas │ └── Supervised/ ← Completed student projects │ └── 4-Resources/ ← Papers, references, literature ``` ### Why This Structure Works **0-Inbox is a guilt-free dumping ground.** Drop ideas without formatting. Screenshots, links, half-sentences—anything goes. The only rule: ideas don't stay here forever. **2-Backlog is your prioritized queue.** Every idea has a score (1-9), an alignment assessment, and an effort estimate. You always know what to work on next. **1-Active enforces focus.** Only one project lives here. When you open this folder, you know exactly what needs your attention. **3-Archive preserves history.** Completed work (shipped) and paused work (parked) live here with full context, so you can resume or reference later. ## The Workflow: Capture → Process → Rate → Assign/Activate → Ship The system follows a strict workflow with two paths after processing: ``` ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ 0-Inbox │────▶│ 2-Backlog │────▶│ 1-Active │────▶│ 3-Archive │ │ (Capture) │ │ (Process) │ │ (Your Work)│ │ (Complete) │ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │ │ ┌─────────────┐ ┌─────────────┐ └───────────▶│ 1-Supervised│────▶│ 3-Archive/ │ │ (Students) │ │ Supervised/ │ └─────────────┘ └─────────────┘ ``` **Two paths from Backlog:** - **Activate** → Work on it yourself → `1-Active/` (ONE project only) - **Assign** → Delegate to students → `1-Supervised/` (multiple allowed) Let me walk through each stage. ### Stage 1: Capture (0-Inbox) **What happens:** You have an idea. You dump it in `0-Inbox/`. **Format:** Anything. A sentence. A link. A screenshot. A rambling paragraph. The goal is **zero friction**—capture the idea before it escapes. **Example inbox note:** ```markdown # GNN for Circuit Discovery What if we used graph neural networks to find circuits in transformers? Instead of expensive ablation studies, train a GNN to predict which components form functional circuits. Links: - ACDC paper: https://arxiv.org/abs/2304.14997 - Anthropic's circuit tracing: transformer-circuits.pub/2025/attribution-graphs Could be really impactful if it works. Check feasibility. ``` That's it. No structure required. Just capture. ### Stage 2: Process (0-Inbox → 2-Backlog) **What happens:** You (with Claude Code's help) transform the raw idea into a structured one-pager. This is where the magic happens. Instead of manually researching and structuring, you run: ``` /process-research-idea ``` The command is executed in its own terminal window, with Claude Code Running in the Obsidian Vault Folder. Especially in the Research subfolder. ({Folder of Obsidian Vault}\Research). The same applies to all the other slash commands in this Procedure. This triggers a multi-phase workflow: 1. **Idea Analysis** — Claude reads the raw idea, follows any links, and extracts key concepts 2. **Literature Search** — Parallel searches across arxiv, semanticscholar, and openreview for related work 3. **Gap Analysis** — What exists? What's missing? Why hasn't this been done? 4. **Alignment Evaluation** — How does this fit your research pillars? 5. **Rating Discussion** — Interactive scoring on Impact, Feasibility, and Fit 6. **One-Pager Creation** — Generate the full document with proper YAML frontmatter 7. **Archive Original** — Move the raw idea to the archived folder 8. **Communicate** - Use Share Note Plugin for communicating notes to other persons. (Share Note community Plugin) The output is a comprehensive one-pager with: - Complete YAML frontmatter (for Dataview queries) - Research question (primary + sub-questions) - Research gap analysis - Planned methodology with steps - Related work table - Alignment assessment - Ratings and effort estimate - Next actions ### Stage 3: Rate (2-Backlog) Every one-pager includes ratings on three criteria: | Criterion | Question | Score | |-----------|----------|-------| | **Impact** | Would this get attention from funders/researchers? | 1-3 | | **Feasibility** | Can we finish in 1-2 months? | 1-3 | | **COAI Fit** | Does it build our reputation in the right areas? | 1-3 | The **total score (1-9)** determines priority. View all scores in the unified dashboard (`_Research-Overview.md`), which auto-generates tables like: ``` | Title | Score | Impact | Feas. | COAI | Risk | Weeks | |--------------------------|-------|--------|-------|------|--------|-------| | GNN Circuit Discovery | 8 | 3 | 2 | 3 | Medium | 10 | | SPHINX Extended Levels | 9 | 3 | 3 | 3 | Low | 6 | | Agent Deception Audit | 7 | 3 | 2 | 2 | High | 8 | ``` ### Stage 4: Activate (2-Backlog → 1-Active) When you're ready to work on an idea, run the following command in Claude Code running in your terminal: ``` /start-research-from-backlog ``` This command: 1. Lists all backlog ideas 2. Let's you select one 3. Detects the research type (Paper, Benchmark, Dataset, Study) 4. Creates appropriate folder structure in `1-Active/` 5. Moves the one-pager and updates the status to `active` 6. Generates README and starter notes The folder structure adapts to the research type: **Paper:** ``` 1-Active/My-Paper/ ├── My-Paper.md ← One-pager ├── README.md ← Overview ├── drafts/v1/ ← Paper drafts ├── figures/diagrams/ ← Visuals ├── reviews/internal/ ← Review feedback ├── submissions/ ← Submission materials ├── notes/ ← Meeting notes, ideas └── literature/ ← Related papers ``` **Benchmark/Platform:** ``` 1-Active/My-Benchmark/ ├── My-Benchmark.md ├── design/architecture.md ├── experiments/configs/ ├── experiments/results/ └── paper/drafts/ ``` ### Stage 5: Execute (1-Active) Work on the project. Use the generated structure: - Track progress in `notes/meetings.md` - Capture ideas in `notes/ideas.md` - Write drafts in `drafts/` - Create figures in `figures/` The one-pager remains your north star—refer to it when scope creep threatens. ### Stage 6: Ship or Park (1-Active → 3-Archive) When complete: - Change status to `shipped` - Move to `3-Archive/` - Celebrate your output! If pausing: - Change status to `parked` - Move to `3-Archive/` - Document why in the Notes section (so future-you understands) ## The One-Pager Template The template is the heart of the system. Every research idea follows this structure: ```markdown --- title: "Research Title" status: idea created: 2026-01-08 last_reviewed: 2026-01-08 phd_relevant: Potential impact: 3 feasibility: 2 coai_fit: 3 total_score: 8 risk: Medium effort_weeks: 10 coai_pillars: - Transparency & Interpretability target_venue: "NeurIPS MI Workshop" project: "" project_role: standalone depends_on: [] enables: [] tags: - research-idea --- # Research Title ## Summary > 2-3 sentences capturing the core idea. ## Introduction ### Why This Matters for Society ### Why This Matters for Science & Industry ### The Vision ## Research Question **Primary Question:** **Sub-Questions:** ## Research Gap **Current State of Research:** **The Gap:** **Why This Gap Exists:** ## Planned Method ### Approach ### Data / Materials Needed ### Tools / Infrastructure Required ### Steps ### Potential Challenges ## Expected Output | Output Type | Target Venue/Platform | Timeline | |-------------|----------------------|----------| | Paper | Conference | | ## Related Work | Paper/Resource | Key Insight | How It Relates | ## COAI Alignment ### Pillar Alignment (Checkboxes for each pillar and sub-area) ### Fit Argument ## Rating | Criterion | Score (1-3) | Reasoning | ## Effort Estimate ## Notes & Discussion Log ### YYYY-MM-DD ## Next Actions - [ ] First action - [ ] Second action ``` ### Why YAML Frontmatter Matters The YAML frontmatter enables **Dataview queries** in Obsidian. You can automatically generate: - Tables of all ideas sorted by score - Filtered views by status, pillar, or project - PhD-relevant ideas only - High-impact opportunities (score >= 7) This transforms your backlog from a pile of files into a queryable database. ## Claude Code Integration: The Automation Layer The real power of this system comes from Claude Code integration. Here's how it works. ### What is Claude Code? Claude Code is Anthropic's AI coding assistant that runs in your terminal. It can read files, execute commands, search the web, and generate content—all while understanding your project context. Claude code can run fully autonomous if you grant access to the folder to the agent environment. ### The CLAUDE.md File Every folder can have a `CLAUDE.md` file that gives Claude Code context about that folder. Mine includes: - Folder structure explanation - Workflow steps - YAML schema for frontmatter - COAI alignment pillars - Instructions for processing ideas When Claude Code opens a session in my Research folder, it reads this file and understands the system. ### Custom Slash Commands Claude Code supports custom slash commands stored in `~/.claude/commands/`. I created four commands for research management: #### 1. `/process-research-idea` **Purpose:** Transform inbox ideas into structured one-pagers. **What it does:** 1. Reads the raw idea from `0-Inbox/` 2. Fetches any linked papers or resources 3. Runs parallel literature searches (arxiv, semanticscholar, openreview) 4. Identifies the research gap 5. Evaluates alignment with research pillars 6. Discusses ratings interactively 7. Creates the one-pager with full YAML frontmatter 8. Saves to `2-Backlog/` 9. Archives the original idea **Example usage:** ``` /process-research-idea ``` Claude will ask which inbox idea to process, or you can specify a file. #### 2. `/generate-research-infographic` **Purpose:** Create presentation-ready visuals from one-pagers. **What it does:** 1. Reads the one-pager 2. Extracts key information (gap, RQ, method, outputs) 3. Generates two infographics via Gemini API: - `{name}_overview.png` — Gap + Research Question + Method Flow - `{name}_detailed.png` — Implementation Steps + Outputs 4. Saves to `2-Backlog/infographics/` 5. Embeds in the one-pager using Obsidian syntax **Example usage:** ``` /generate-research-infographic @2-Backlog/My-Idea.md ``` This requires a `GEMINI_API_KEY` environment variable and a Python script (`research_infographic_generator.py`). #### 3. `/start-research-from-backlog` **Purpose:** Activate a backlog idea and create project structure. **What it does:** 1. Lists all backlog ideas 2. Detects research type (Paper, Benchmark, Dataset, Study, Extension) 3. Creates appropriate folder structure in `1-Active/` 4. Moves the one-pager and updates status 5. Generates README with overview 6. Creates starter notes (meetings.md, ideas.md, related-papers.md) **Example usage:** ``` /start-research-from-backlog ``` #### 4. `/backlog-assign-ideas` **Purpose:** Assign backlog ideas to students and create supervision structure. **What it does:** 1. Lists all unassigned backlog ideas 2. Asks how many people to assign 3. For each person: collects name, role (lead/contributor), type (PhD/Master/Other) 4. Creates folder structure in `1-Supervised/` 5. Creates Progress-Log.md and kickoff meeting template 6. Moves the one-pager and updates YAML frontmatter 7. Adds Dataview sections for supervision dashboard **Example usage:** ``` /backlog-assign-ideas ``` Claude will guide you through the interactive assignment process. ### Creating Your Own Slash Commands Slash commands are Markdown files in `~/.claude/commands/`. Here's the structure: ```markdown # Command Title Description of what the command does. ## Your Workflow ### Step 1: First Step Instructions for Claude... ### Step 2: Second Step More instructions... ## Output What Claude should produce. ``` The file name (without `.md`) becomes the command name. For example: - `process-research-idea.md` → `/process-research-idea` - `generate-research-infographic.md` → `/generate-research-infographic` ## Setting Up the System: A Step-by-Step Guide Here's how to build this system yourself. If you want to follow exactly my system and my commands. Feel free to contact me with the information of your github user and I would add you to the repository which contains the claude MD file, skills and commands for this worfklow. ### Step 1: Create the Folder Structure ```bash mkdir -p Research/{0-Inbox,1-Active,2-Backlog/_Projects,3-Archive/Archived-Ideas,4-Resources} mkdir -p Research/2-Backlog/infographics ``` ### Step 2: Create the Templates **_Template-Research-Idea.md** — Copy the one-pager template from above. **2-Backlog/_Projects/_Template-Project.md** — For multi-paper projects: ```markdown --- title: "[Project Name]" type: project status: idea | active | completed | paused created: YYYY-MM-DD papers: [] tags: - project --- # [Project Name] ## Project Overview > 2-3 sentences describing the overall project. ## Research Papers / Outputs | Paper | Status | Role | Dependencies | Target Venue | |-------|--------|------|--------------|--------------| | [[Paper-1]] | idea | foundation | - | Venue | ## Timeline & Dependencies (Mermaid diagram showing paper relationships) ## Shared Resources - **Code Repository:** - **Data Location:** ``` ### Step 3: Create CLAUDE.md Create a `CLAUDE.md` in your Research folder. Include: 1. Your folder structure 2. Your workflow 3. Your alignment pillars (what makes a good idea for YOU?) 4. The YAML schema 5. Instructions for Claude Code ### Step 4: Create the Dataview Dashboard Create `_Research-Overview.md` in your Research folder root: Dataview is a community extension in Obsidian that lets users treat other notes as a Database and query them in an SQL-like Syntax. Therefore, metainformation has to be integrated into each note. ```markdown # Research Backlog Overview ## All Research Ideas \`\`\`dataview TABLE WITHOUT ID link(file.link, title) AS "Title", status AS "Status", total_score AS "Score", impact AS "Impact", feasibility AS "Feas.", coai_fit AS "Fit", risk AS "Risk", effort_weeks AS "Weeks" FROM "Research/2-Backlog" OR "Research/1-Active" WHERE contains(tags, "research-idea") SORT total_score DESC \`\`\` ## High-Impact Ideas (Score >= 7) \`\`\`dataview TABLE WITHOUT ID link(file.link, title) AS "Title", total_score AS "Score", target_venue AS "Venue" FROM "Research/2-Backlog" WHERE contains(tags, "research-idea") AND total_score >= 7 SORT total_score DESC \`\`\` ``` ### Step 5: Install Claude Code ```bash npm install -g @anthropic-ai/claude-code ``` For this step, you need a Subscription to Claude; the best option is Claude Pro or Claude Max. Where Claude Code could be used as a multi-agent system besides Obsidian without any additional Token costs. This is important, because the Claude Code is consuming quite a lot of tokens through the process. ### Step 6: Create Custom Commands Create the commands directory: ```bash mkdir -p ~/.claude/commands ``` Create `~/.claude/commands/process-research-idea.md` with the processing workflow (see the full command in my repository). ### Step 7: (Optional) Set Up Infographic Generation Install requirements: ```bash pip install google-genai Pillow ``` Set your API key: ```bash export GEMINI_API_KEY="your-key" ``` Create the Python script at `~/.claude/scripts/research_infographic_generator.py`. For Image And Graphic generation, I use Gemini Nano Banana Pro. This model is from Google and is one of the best Image Generation models, capable of handling Illustration and including correct Text in images. This model is based on the costs of api token consumption. Each Illustration will cost around 0.20 euros. You need a Gemini API Key from Google AI Studio. --- ## Project Hubs: Managing Multi-Paper Research Some research produces multiple related papers. For example: - Paper 1: Platform/methodology (foundation) - Paper 2: Dataset release - Paper 3: Findings/analysis These belong to a **Project Hub**. ### Creating a Project Hub Create `2-Backlog/_Projects/My-Project.md`: ```markdown --- title: "My Research Project" type: project status: active papers: - "My-Platform-Paper" - "My-Dataset-Paper" tags: - project --- # My Research Project ## Research Papers | Paper | Status | Role | Dependencies | |-------|--------|------|--------------| | [[My-Platform-Paper]] | active | foundation | - | | [[My-Dataset-Paper]] | idea | dataset | Platform Paper | ``` ### Connecting Papers to Projects Each paper's frontmatter includes project fields: ```yaml project: "My Research Project" project_role: foundation # or dataset, findings, extension depends_on: [] # papers this one requires enables: ["My-Dataset-Paper"] # papers this enables ``` The Dataview dashboard can filter by project to show dependencies and progress. --- ## Supervised Projects: Managing Student Research As a professor supervising ~8 PhD students and ~5 Master students, I needed a way to track assigned research without cluttering my personal workflow. The solution: a dedicated `1-Supervised/` folder that keeps student projects visible but separate from my own active work. ### The Supervision Challenge Before this system, I had several problems: 1. **Backlog confusion** — Ideas assigned to students still appeared as "available" in my backlog 2. **Progress invisibility** — Student progress lived in emails and sporadic meetings 3. **Context fragmentation** — Meeting notes, action items, and one-pagers were scattered The solution separates "ideas waiting to be worked on" (Backlog) from "ideas being worked on by students" (Supervised). ### The `/backlog-assign-ideas` Command When assigning a research idea to students, run: ``` /backlog-assign-ideas ``` This triggers an interactive workflow: 1. **Select idea** — Choose from unassigned backlog items 2. **Team size** — Specify how many people to assign 3. **For each person** — Enter name, role (lead/contributor), and type (PhD/Master/Other) 4. **Create structure** — Automatically sets up the supervision folder 5. **Move one-pager** — Relocates from Backlog to Supervised with updated status ### Supervised Project Structure Each assigned project gets its own folder: ``` 1-Supervised/ └── LLM-Deception-Detection/ ├── LLM-Deception-Detection.md ← One-pager (now with Dataview dashboard) ├── Progress-Log.md ← Single file with dated entries └── Meetings/ ├── 2026-01-15-Kickoff.md └── 2026-01-22-Weekly.md ``` ### Extended YAML Frontmatter When assigned, the one-pager's frontmatter expands: ```yaml status: supervised # Changed from "idea" supervised_status: in_progress # assigned | in_progress | under_review | revision | submitted assignment_date: 2026-01-15 assigned_to: - name: "Max Müller" role: lead type: PhD - name: "Anna Schmidt" role: contributor type: Master ``` This enables Dataview queries to show: - All supervised projects by status - Projects by student - Upcoming deadlines ### The One-Pager Becomes a Dashboard After assignment, the one-pager automatically includes Dataview sections: ```markdown ## Supervision Dashboard ### Team | Name | Role | Type | |------|------|------| | Max Müller | lead | PhD | | Anna Schmidt | contributor | Master | ### Recent Meetings (Auto-populated from Meetings/ folder) ### Open Action Items (Aggregated from all meeting notes) ### Progress Log (Embedded from Progress-Log.md) ``` Everything related to the project is visible in one place. ### Progress Tracking The `Progress-Log.md` file uses a simple format: ```markdown ## 2026-01-22 **Status:** On Track ### Completed - Literature review finished - Initial experiment design ### In Progress - Implementing baseline model ### Blockers - Need GPU cluster access ### Next Steps - Run first experiments by Friday ``` This format works well in supervision meetings—students can update it before meetings, and I can see progress at a glance. ### Meeting Notes Template Each meeting in `/Meetings/` follows a structured template: ```markdown --- date: 2026-01-22 attendees: ["Max Müller", "Anna Schmidt", "Prof. Schacht"] type: weekly --- ## Agenda - [ ] Review experiment results - [ ] Discuss methodology changes ## Discussion (Key points from the meeting) ## Action Items - [ ] **Max:** Run ablation study — Due: 2026-01-29 - [ ] **Anna:** Update literature review — Due: 2026-01-26 - [ ] **Prof. Schacht:** Review draft introduction — Due: 2026-01-25 ## Next Meeting 2026-01-29 ``` Action items with checkboxes appear automatically in the one-pager dashboard via Dataview. ### Completing Supervised Projects When a student project is completed: 1. Update `supervised_status: submitted` (or `shipped`) 2. Move the entire folder to `3-Archive/Supervised/` 3. The `1-Supervised/` folder stays clean as "active student work only" ### Why This Matters for Supervisors 1. **Clear separation** — My active project stays focused; student work is visible but separate 2. **Backlog stays clean** — Only truly unassigned ideas remain in `2-Backlog/` 3. **Progress visibility** — I can see all student progress without digging through emails 4. **Meeting efficiency** — Structured notes mean less "what did we discuss last time?" 5. **Accountability** — Action items are tracked and visible For professors supervising multiple students, this system transforms supervision from a scattered email-and-meeting practice into a structured, queryable knowledge base. --- ## Why This Matters: The Case for Structured Research You might think: "This seems like overhead. Can't I just... do research?" Here's why the structure pays off: ### 1. Ideas Don't Die Before this system, I constantly lost ideas. Now every idea gets captured, processed, rated, and either activated or explicitly parked. Nothing falls through the cracks. ### 2. Focus Increases Output One active project means deep work instead of context switching. I ship more papers now than when I was "working on" five projects simultaneously. ### 3. Alignment Prevents Drift Every idea passes through an alignment check. This prevents the common failure mode of academics: working on whatever seems interesting instead of building toward a coherent research program. ### 4. AI Augmentation Saves Hours The `/process-research-idea` command does in 10 minutes what used to take 2-3 hours: literature search, gap analysis, structuring, rating. This isn't about replacing thinking—it's about accelerating the boring parts so you can spend more time on the interesting parts. ### 5. Reproducibility for Your Lab Once you have this system, your PhD students can use it too. Same templates, same workflow, same alignment checks. Research quality becomes systematic, not individual. ### 6. Better communication in Research Group My hope by using this system is that communication in a Research Group follows more or less a scientific exchange about Research ideas, Procedures, and Results, with written Feedback. Using this system, I hope to use this kind of one-pager as a communication platform to share research ideas with PhD or Master Students, as a research task or discussion point. I would expect that if all my students use this kind of one-pager, the discussion of ideas and exchange between participants of my research group should be much more formalized and standardized. The goal would be to spend more time on research, not just communicating ideas, or to make me, as a Supervisor, the communication hub between all PhD Students (which was the case in the past). The role of exchanging ideas is to provide research ideas to others in the group in written one-pager form, and to allow others to comment on them (review) or understand the interconnection to their own research. Research Ideas can now be communicated using the excellent Share Note Community Plugin in Obsidian, which uploads the Obsidian note, including pictures, in a fully encrypted format to a shared server, and a sharing link is provided. ## For PhD Students: How to Adapt This System If you're a PhD student, here's how to customize this for your needs: ### Define Your Alignment Pillars Replace my COAI pillars with your own. These might be: - Your thesis themes - Your advisor's lab focus areas - Your career goals (academia vs. industry) - Funding requirements Every idea should pass through your pillars. ### Adjust the Rating Criteria My criteria (Impact, Feasibility, COAI Fit) may not match yours. Consider: - **Thesis Progress**: Does this advance your dissertation? - **Publication Potential**: Can this become a paper? - **Skill Development**: Does this teach you something valuable? - **Collaboration Opportunity**: Does this connect you with researchers you want to work with? ### Start Small You don't need all the automation immediately. Start with: 1. The folder structure 2. One template for one-pagers 3. The single-active-project rule Add Claude Code commands later as you get comfortable. ### Use the Backlog for Your Advisor The prioritized backlog is great for advisor meetings. Instead of vague updates, you can show: - "Here's my active project (1-Active)" - "Here are my rated next projects (2-Backlog, sorted by score)" - "Here's what I'm capturing but not ready to start (0-Inbox)" This demonstrates organized thinking and makes prioritization discussions concrete. ## Conclusion: Systems Beat Willpower Research is hard. Ideas are fragile. Focus is rare. The solution isn't to try harder—it's to build systems that make the right behavior easy. This system makes it easy to: - Capture ideas without friction - Process ideas with rigor - Prioritize based on explicit criteria - Focus on one thing at a time - Ship consistently Claude Code isn't magic. Templates aren't magic. Folder structures aren't magic. But combined into a coherent system, they create an environment where good research practices happen automatically. Build the system. Trust the system. Ship the work. ## Related Systems This research management system integrates with other productivity tools I've built: - **[[Daily Reading Notes Happit System|Daily Paper Reading System]]** — A companion system for systematic paper reading. Uses weighted random selection to pick one paper per day, generates AI-powered reading guides with COAI-aligned questions, and transforms reading notes into Zettelkasten atomic notes. Papers you read connect directly to your backlog, creating a virtuous cycle of reading → ideas → research. ## Resources ### Files You'll Need 1. `CLAUDE.md` — Claude Code context file 2. `_Research-Overview.md` — Unified Dataview dashboard (backlog + supervised + active) 3. `_Template-Research-Idea.md` — One-pager template 4. `_Template-Project.md` — Project hub template 5. `_Template-Meeting.md` — Supervision meeting template 6. `_Template-Progress-Log.md` — Progress tracking template 7. `~/.claude/commands/process-research-idea.md` — Processing command 8. `~/.claude/commands/generate-research-infographic.md` — Infographic command 9. `~/.claude/commands/start-research-from-backlog.md` — Activation command 10. `~/.claude/commands/backlog-assign-ideas.md` — Student assignment command ### Tools Required - [Obsidian](https://obsidian.md) — Note-taking with Dataview - [Claude Code](https://docs.anthropic.com/claude-code) — AI assistant - [Dataview Plugin](https://github.com/blacksmithgu/obsidian-dataview) — Query your notes - (Optional) Gemini API for infographics ### Quick Reference | Action | Command | |--------|---------| | Process new idea | `/process-research-idea` | | Generate infographics | `/generate-research-infographic @file.md` | | Start working on idea | `/start-research-from-backlog` | | Assign idea to students | `/backlog-assign-ideas` | | View all research | Open `_Research-Overview.md` | | Select daily paper | `/daily-paper` | | Atomize reading notes | `/atomize-reading-notes` | | View reading dashboard | Open `6-Reading/_Reading-Overview.md` | --- *Questions? Reach out at sigurd.schacht [at] hs-ansbach.de or find me at COAI Research Institute, Nuremberg. https://coairesearch.org*