
The productivity race is heating up, and if you're not **skillmaxing**, you're already behind! (Don't believe me?) On April 26, 2025, Sam Altman sparked a fire on X with [a post](https://x.com/sama/status/1915826042729861357) that racked up 4.4 million views: "if you are not skillsmaxxing with o3 at minimum 3 hours every day, ngmi." In plain terms, he's saying use AI to max out your skills, or you won't make it. With the AI world moving at lightning speed, let's explore how **skillmaxing** helps you learn fast, why you need to start today, and how to jump in.

So, what's **skillmaxing**?\
It's the smart way to use AI to supercharge your learning and skills. This isn't about AI taking over your work (not a chance!). It's about partnering with AI to soak up knowledge quicker than ever. Imagine you're a coder trying to learn JavaScript. You ask AI for a function to sort arrays, then tweak the code to make it faster. Or maybe you're a designer needing to grasp UX trends. AI pulls the latest insights, and you mix in your creativity for a standout project. That's **skillmaxing**: using AI to unlock knowledge fast, while you stay in control, steering clear of Big Tech's bloated, data-hungry platforms.

Here's why **skillmaxing** makes learning a breeze:

- **Instant answers**: Get clear explanations on anything (like JavaScript loops or UX principles) in a flash.
- **Real examples**: AI hands you sample code or ideas to practice with (no more digging through forums!).
- **Learn by doing**: Spot AI's mistakes, fix them, and grow your skills on the fly.
- **Stay curious**: Ask AI to break down new topics (like blockchain or neumorphism) anytime.

**Why the rush?**\
The productivity landscape is moving at warp speed. New AI tools drop daily, and those who **skillmax** are already ahead, producing better work faster. Sam Altman's "ngmi" warning isn't a joke: if you don't keep up, you'll be left in the dust. Start **skillmaxing** today. Pick an AI tool, try it for coding, designing, or brainstorming (it's easier than you think!). Don't wait to max your skills, jump in and lead the way!

> Check out [The art of skillmaxing](/culture/skillmaxing)


Explains 'skillmaxing,' using AI for accelerated learning and skill development in a fast-changing world, and why it's crucial now.

What is skillmax?


> **tl;dr**
>
> Developers can access Brainery's data and LLM power using a simple **MCP configuration**. Integrate the **Model Context Protocol (MCP)** into your tools to seamlessly query insights and use AI features directly in your workflow.

We want you to easily tap into the collective knowledge and AI power of **Brainery**. The main way to do this is through our **Model Context Protocol (MCP)**.

Think of **MCP** as the universal key to unlock Brainery’s data and its smart Large Language Model (LLM) features. It’s the standard way we ensure different tools and services can talk to Brainery smoothly and reliably, as we detailed in the [Brainery architecture](architecture.md).

**What this means for you as a developer:**

Good news! You don’t need to wrestle with a whole new set of complex APIs for everyday access. We’ve focused on making integration simple. You can bring Brainery’s power into your go-to tools, scripts, or development environments by just adding an **MCP configuration**.

Once configured, you can:

* Query for specific data points or insights.
* Ask the LLM to process or summarize information.
* Fetch connected ideas and trends directly within your workflow.

Essentially, adding the **MCP config** to your environment lets you make **Brainery** a natural extension of how you already work. We believe this approach makes accessing our second brain both powerful and practical for your daily tasks.

---

> Next: [Reading after brainery]()


This page outlines how developers can connect to and utilize Brainery's extensive knowledge base and AI-driven capabilities. By integrating a straightforward MCP configuration, you can seamlessly access powerful insights directly within your existing development tools and workflows.

Access the brainery


> **tl;dr**
>
> Brainery uses a multi-part architecture: **Fortress DB** for structured data, a **Landing area** for raw unstructured data, and a **Pipeline** that processes everything into the **brainery-db**. This core **TimescaleDB** is accessed via the **MCP Server** to turn diverse inputs into a living knowledge base.

Our second brain project, internally known as **Brainery**, is engineered to be more than just a data repository; it's a dynamic and evolving **knowledge base**. It’s designed to empower you to truly understand and connect disparate pieces of information, moving beyond simple AI queries to genuine insight. This article will walk you through the architecture that makes this possible, explaining how data flows and transforms into actionable knowledge.

![](assets/architecture.png)

### Data: The foundation of knowledge

At the heart of any "second brain" is data. The diagram you see shows how various types of data, each with its own characteristics, serve as the raw material for **Brainery**. We've categorized these sources to clarify how we handle them:

* **Private data (structured):** This category encompasses internal information that is already well-organized, such as `members`, `projects`, `accounting`, `clients`, and `subscriber` data. This **structured data** is primarily fed into the **Fortress DB**.
* **Protected data (unstructured):** This includes internal communications like `memo` (internal notes), `interactions`, and `discord` conversations. This **unstructured data** is channeled into a **Landing area**.
* **Public data (unstructured):** This is information gathered from public sources like `social data`, `reddit`, `job post` information, `fund raise` details, and `github` repositories. This also goes to the **Landing area**.

### Processing and storage: Transforming data into insights

Collecting data is just the first step. The real power of **Brainery** comes from how this data is processed, stored, and interconnected.

1. **Fortress DB:**

* This is a **relational database** (e.g., PostgreSQL, MySQL) storing structured private data in tables. It's ideal for precise queries using **SQL**.
* Input is managed by our operations team, and it serves web applications needing reliable, transactional data.
* Eventually, its data will also be treated as derivatives from the **Brainery DB** for a unified analytical view.

2. **Landing area (collector):**

* This is an initial aggregation point for **unstructured** and **semi-structured data** (from protected and public sources) before it enters the main processing pipeline.
* Data is often stored in **Parquet files**, a columnar format optimized for big data analytics, typically within **cloud storage** (GCP, AWS).
* It's crucial for our **social listening module**, capturing external signals.

3. **Pipeline (consume):**

* Data from **Fortress DB** and the **Landing area** is processed by this pipeline to prepare it for the **Brainery DB**.
* It uses a **Background Interface** (often an LLM) and an **MCP (Model Context Protocol) Server**. **MCP** standardizes data exchange between services and models, ensuring consistent communication.

4. **Brainery DB:**

* The core of our system, built on **TimescaleDB**, an extension of PostgreSQL optimized for **time-series data**.
* It features an `observation_log` **hypertable**, which auto-partitions data by time for efficiency. This uses an **append-only design**, meaning new data is added without altering existing records, ensuring an immutable history.
* This database cultivates:
  * An `observation state log`: The foundational record of all ingested data.
  * `deriv. notes`: LLM-generated summaries and interpretations.
  * The `sum of collective intelligence`: Holistic knowledge from all connected sources.
  * `insight`: Significant understandings from pattern analysis.
  * `operational` data, `connections` (relationships between data), `practices` (learned procedures), and `trends`.
* **LLMs** analyze observations here, detect trends, and can even coin new terms for novel patterns.

5. **MCP server:**

* The primary gateway for interacting with the **Brainery DB**, enforcing the **MCP** standard.
* It handles requests for parsing, structuring, storing data in **TimescaleDB**, and executing queries.
* This allows tools like **LLM-powered chatbots** to use natural language to query the **Brainery DB** through a standardized interface.

### The goal: A living knowledge base

This architecture aims to create a **living knowledge base** that grows and adapts. By systematically capturing, structuring, and intelligently processing diverse data, **Brainery** helps us uncover insights, track trends, and foster continuous learning and informed decision-making.

---

> Next: [Database design](database-design.md)


An overview of Brainery's architecture, detailing how it ingests, processes, and transforms data from diverse sources into a dynamic knowledge base.

Architecture


Our content starts as rough ideas and matures into polished insights. Here’s how we break it down into four levels, each with a clear purpose.

### Level 1: Fleeting notes in `notes/`

Every idea starts somewhere. In the Memo, new thoughts land in the notes/ folder as **fleeting notes**, quick drafts capturing project insights, questions, or sparks of curiosity. Anyone on the team can add to this folder, making it a low-pressure way to share.

Each week, our sorting bot tidies these notes. It updates the frontmatter (metadata like title, tags, and author) and suggests where the note belongs based on its strongest tag. For example, a note about JavaScript might get flagged for `topics/engineering/javascript/`. This keeps our ideas organized and ready for the next step.

!["Content levels"](assets/content-level.webp)

### Level 2: Permanent notes in `topics/`

Once polished, notes move to the `topics/` folder as **permanent notes**. These are organized into **Maps of Content (MoC)**, linked collections grouped by theme, like engineering or culture. A filtering engine scans each note’s content and tags, recommending where it fits, ensuring every article finds its home.

Articles here focus on the basics: **what** a topic is, **why** it matters, and **how** to use it. For example, a note might explain “What is React, why it’s useful, and how to build with it.” These notes form a content map, feeding into our **second brain database** for easy access and future reference.

### Level 3: Playbook articles

Playbook articles take knowledge to the next level. Stored separately, these focus on **processes**, **practices**, and **lessons learned**. They’re practical guides, like how we streamline code reviews or manage remote teams. Think of them as recipes for getting things done, built from real experience. Like other content, playbooks feed into our second brain database, making them reusable across projects.

### Level 4: Build-logs

Alongside playbooks, `build-logs/` document specific projects and their challenges. These case studies follow a “problem-solution” format, capturing what we learned while building something like the Memo itself. For example, a build-log might detail how we designed the sorting bot, including technical hurdles and solutions. These logs are stored with playbooks and also enrich our second brain database.

## How the system works

Our content arrangement is like a well-tended garden: it starts with scattered seeds (fleeting notes) and grows into a structured landscape (permanent notes, playbooks, and build-logs). The Zettelkasten approach keeps ideas connected, so nothing gets lost. Content flows through these steps:

1. **Capture:** Team members add fleeting notes to notes/.
2. **Refine:** The sorting bot formats and categorizes notes weekly.
3. **Organize:** Polished notes move to topics/, playbooks, or build-logs, linking to related content.
4. **Share:** Content is published via GitHub Pages to [memo.d.foundation](https://memo.d.foundation/) and stored in our second brain database.

This system makes knowledge easy to find and use, both for our team and the wider community

---

> Next: [Make a MoC](make-a-moc.md)


This guide explains how we organize content in our Memo using a Zettelkasten-inspired system, from fleeting notes to playbooks. Learn how to contribute and build our connected knowledge base.