How I Built a 10-Table AI Content Command Center with Lark Multidimensional Sheets — Full Tutorial

I’m going to open up my entire content production system for you today — 10 interconnected tables that I use every single day as a content creator. I’ll show you how to build a minimum viable version using Lark (Feishu) Multidimensional Sheets with AI, and hand you copy-paste prompts for Codex to automate the whole pipeline. No command-line experience required.

The Problem Every Content Creator Knows Too Well

As an independent content creator, the app I open most often isn’t Word — it’s three browser windows side by side. One for my daily AI news digest, another for curated viral articles from WeChat Official Accounts, and a third for my X (Twitter) bookmarks. I’ve scrolled past the point of no return in that bookmark folder.

Friday afternoons are the worst. When I want to do a weekly review, I have to scrape together data from everywhere — pull reading stats from the WeChat backend, click through X posts one by one to check engagement, and dig through chat logs to remember what I published last month. The most painful part? I know I saved an incredible piece of insight three days ago, but when I actually need it, I can’t remember where I put it.

All I really wanted was simple: one single place where I could see what material I had, what I should write today, and how my last piece performed — no more digital scavenger hunts across my entire computer.

That’s when ByteDance launched Lark Multidimensional Sheets, and I immediately used its built-in AI to build myself a command center. One table wasn’t enough, so I kept adding. Today, I’m running 10 tables.

Part 1: What My System Looks Like Right Now

AI Content Workbench — System Overview (One Continuous Pipeline)

I call this system the “AI Content Workbench.” Here’s how the pipeline flows from morning to night.

Three Input Channels

1. AI HOT Event Database — Collects noteworthy events from AI daily digests, API announcements, and RSS feeds. Each item gets a value rating: S-tier means I must cover it today; A-tier gets saved for later.

2. WeChat Viral Article Library — Stores headline formulas, article structures, and reusable angles from top-performing WeChat Official Account articles.

3. X (Twitter) Intelligence Library — This one takes the most effort. Every morning at around 2 AM, a scheduled Codex task scrapes fresh posts from X, BestBlogs, and similar sources. I filter them by category: counter-intuitive takes, industry predictions, genuine questions, and technical debates. Surviving items pass one final test — the “stranger filter.” I ask myself: if I didn’t know who wrote this, would I still find it worth sharing? If not, it’s gone.

Where Everything Converges

These three streams feed into a Daily Material Dashboard — one entry per day. When I spot something worth keeping long-term, I break it down into knowledge cards. From there, the flow continues through the Topic Pool, Article Draft Library, Task Board, and Cover Asset Library.

The Topic Pool: Scoring Every Idea on Four Dimensions

The Topic Pool is my proudest table. Every piece of daily material gets transformed into a candidate topic here, and I score each one on four dimensions — all rated 1 to 5 stars:

H — Curiosity (How badly do I want to know more?)
K — Knowledge Density (How much value can the reader gain?)
R — Resonance (Will readers feel “this is about me”?)
E — Ease of Writing (Can I write this well without it becoming a slog?)

The Recommendation Score is a simple sum of all four, maxing out at 20. Crude, but far better than guessing.

Topic Scoring: Curiosity + Knowledge + Resonance + Ease → Recommendation Score → Priority

Let me walk you through a real example from May 8th:

Topic A — How AI Agents evolved from toolbar buttons to full-day copilots that take over Office, browsers, and terminals. Scores: $H 5 K 5 R 4 E 4$ = 18 points.

Topic B — Why every viral WeChat article is writing about Claude Code. Scores: $H 5 K 4 R 5 E 5$ = 19 points.

Both scores are high. Both are worth writing. But which one gets published first? That depends on timeliness, not score. Topic A was riding a hot news cycle that very day, so I marked it P0 (publish today). Topic B is evergreen content — it’s not going anywhere, so I bumped it to P1. You’ll notice the 18-pointer outranks the 19-pointer, and that’s by design: the Recommendation Score tells you whether a topic is worth writing; the Priority tells you which one goes out today.

Real Topic Pool — 300 active topics (top bar shows the 10 tables)

Real Topic Pool — 300 active topics running (top bar shows tables 00–09)

Each topic also requires a written-out Core Question, Reader Takeaway, Why This Matters, and a column I call the “Argument Gap” — specifically noting where others haven’t gone deep enough and where I can add a sharper cut. After publishing, I log engagement at 24 hours, 48 hours, and 7 days, and I back-link to which original material inspired the piece.

💡 What Lark Multidimensional Sheet AI does in this system:

① I built the structure and fields of all 10 tables by feeding it instructions one at a time. ② For reviews, I almost never write formulas — I just ask questions in plain language. ③ For weekly and monthly reports, I let it generate charts directly; I just read them.

Lark Multidimensional Sheet AI Panel: Table Building / Dashboard Building / Data Analysis

Part 2: Don’t Start with 10 Tables — Start with 5

My system grew from one scrappy table to five, then to ten, over the course of nearly a year. Don’t let the full setup intimidate you. Start with the minimum viable version: Material Library, Topic Pool, Production Tasks, Publishing Calendar, and Data Review. Five tables. That’s all you need.

The easiest approach: don’t design them yourself — let Lark Multidimensional Sheet AI do it in one shot. Open Lark, create a new Multidimensional Sheet, and find the AI input. Don’t say something vague like “build me a content workbench.” The more specific you are, the better the output. Here’s exactly what I typed:

Build me a content team workbench with 5 tables:

Material Library — fields: title, source link, source platform, local file path, suitable content direction, whether it's been used.

Topic Pool — fields: title, core question, reader benefit, angle, target platform, plus four ratings (Curiosity/Knowledge/Resonance/Ease), recommendation score, status, linked materials.

Production Tasks — fields: assignee, deadline, draft status, review status, publish status.

Publishing Calendar — schedule by date for WeChat, Toutiao, X, and Xiaohongshu.

Data Review — fields: reads, saves, comments, lead conversions, review notes.

Send your requirements to Lark Multidimensional Sheet AI in one message

AI begins building the entire workbench based on your requirements

5 tables built instantly — with sample data pre-filled

5 tables built in one go — sample data even gets filled in automatically

✅ Success checkpoint: You should see five tables in Lark, each with a clear purpose. The Topic Pool’s four rating columns should be clickable stars, and the Recommendation Score should auto-sum.

Part 3: Get the Review Loop Running First

Don’t chase full automation right away. Start with the part that’s easiest to skip but proves the most value — the review cycle.

Lark’s AI Q&A (Ask Your Data) feature lets you ask questions in plain English, and it searches the tables for answers. No formulas. No pivot tables. Try questions like:

What are the highest-scoring topics from the last 30 days?
Which topics are written but still unpublished?
Which platform had the highest average reads last month?
How many materials in the library are marked “used” vs. untouched?

The real test isn’t how pretty the answer looks — it’s whether the AI can find the right records and link back to the original table. If it does, you can immediately follow up by changing a status or filling in a missing field.

AI Q&A: instant answers with back-links to the source table

AI Q&A: ask in plain language, get instant answers with links back to source data

Charts work the same way. Don’t build a showpiece dashboard. Make three charts you’d actually look at on a Friday afternoon: articles published per platform this month, topic status distribution, and which content category drives the best reads. Open Lark in the afternoon, and the data is right there — no assembly required.

Lark AI auto-generated content dashboard

Lark Multidimensional Sheet AI auto-generated content dashboard

Part 4: Level Up — Automate Table Creation and Data Collection with Codex

The first three steps happen entirely inside the Lark web UI, with zero command-line work. But if you’re willing to invest a bit more effort — installing Codex and the Lark CLI — you can build a true automation pipeline where Codex runs scheduled tasks daily, scraping, organizing, and writing data directly into your Multidimensional Sheets.

This layer relies on two tools: Codex handles the thinking — generating and executing commands — while Lark CLI (lark-cli) is the official command-line tool that actually reaches into Lark to read and write data.

4.1 Install Codex and Lark CLI

Codex comes in two flavors: a Desktop App and a Command-Line Interface (CLI). I use the desktop app — the scheduled automation feature covered in section 4.4 is exclusive to the desktop app; the CLI doesn’t have it. Both versions can call lark-cli to operate on Lark, and the prompt in section 4.2 works with either.

Option A: Install the Desktop App (Recommended)

Go to OpenAI’s official Codex page and download the app for macOS or Windows. Open it, log in with your OpenAI or ChatGPT account, and you’re ready to chat, execute commands, and set up scheduled tasks.

Option B: Install the CLI (for terminal enthusiasts)

# Install Codex (pick one method)
npm install -g @openai/codex
brew install --cask codex          # macOS via Homebrew

The first time you run codex, it will prompt you to log in with your OpenAI account — follow the terminal instructions. Don’t skip this step. If the account isn’t authenticated, everything downstream will break in the most boring way possible.

Codex installed — version number confirms success

Codex installed — seeing the version number means you’re good

Next, install Lark CLI — Codex’s “hands” for operating Lark Multidimensional Sheets:

# Install (official recommended method)
npx @larksuite/cli@latest install

# Initialize configuration
lark-cli config init

Then authorize access. It’s simpler than you’d expect — no need to create an app in the Lark Open Platform or manually check permission boxes. Run this command, and it pops up an authorization link (or QR code). Scan it with the Lark app, tap approve, and all permissions are granted in one go:

# Authorize (opens a link/QR — scan and approve; scopes accumulate)
lark-cli auth login --recommend

# Verify login status
lark-cli auth status

# Critical test: listing your tables confirms real connectivity
lark-cli base +table-list --as user

⚠️ The authorization step requires you to scan the QR and tap approve — AI can’t do this for you. If +table-list returns no tables, you probably missed a permission during the scan. Re-run lark-cli auth login --recommend and scan again.

Scan QR → Authorization confirmation screen → tap “Authorize and Enable”

Scan the QR code → See the authorization screen → Tap “Enable and Authorize” to unlock all permissions at once

Seeing “Authorization Successful” means you’re connected

Terminal showing lark-cli reading all 10 tables from Lark

Terminal: lark-cli successfully reads all 10 tables from Lark

4.2 One Prompt to Auto-Build the Entire Table System (Copy & Paste)

Don’t want to click through Lark manually? Paste the entire block below into Codex (desktop app or terminal). It will use lark-cli to create the database, tables, fields, scoring system, recommendation formula, and write a test record to verify everything works. Just confirm each dry-run step as it goes:

You are my Lark Multidimensional Table builder. lark-cli is already installed and authenticated on my machine (--as user, with read/write permissions on Multidimensional Sheets). Use lark-cli to build an "AI Content Workbench" for me. Use real commands only — do not invent commands or field types. For every write operation, do a --dry-run first so I can review the command before you execute.

Step 1 — Verify the environment (stop and tell me if it's a login or permission issue):
  lark-cli auth status
  lark-cli base +table-list --as user

Step 2 — Create the database + first table. Save the returned base_token:
  lark-cli base +base-create --name "AI Content Workbench" --table-name "01 Daily Material Dashboard" \
    --fields '[{"name":"Date","type":"date"},{"name":"Source Channel","type":"select","options":[{"name":"AI Daily"},{"name":"WeChat"},{"name":"X"},{"name":"Local"}]},{"name":"Today Top Event","type":"text"},{"name":"Material Summary","type":"text"},{"name":"Collection Status","type":"select","options":[{"name":"Pending"},{"name":"Collected"}]}]' --as user

Step 3 — Use base +table-create --base-token <token from step 2> to create each table below, one by one:
  · 02 AI HOT Event DB: Event Title(text), Category(select: Model/Product/Industry/Paper/Technique), Value Rating(select: S/A/B), Source URL(url), Summary(text)
  · 03 WeChat Viral Article Library: Title(text), Benchmark Account(text), Headline Formula(text), Structure Breakdown(text), Reusable Angles(text), Full Text Accessible(checkbox)
  · 04 X Intelligence Library: Post Topic(text), X Handle(text), Hook Type(select: Counter-intuitive/Industry Judgment/Real Question/Technical Debate), Signal Summary(text), Quotable Point(text), Original Link(url)
  · 05 Knowledge Card Library: Card Title(text), Type(select: Fact/Opinion/Case Study/Headline Formula), Content(text), Rewritten Angle(text), Usage Boundaries(text)
  · 06 Topic Pool (with scoring): Topic Title(text), Core Question(text), Reader Benefit(text), Angle(text), Target Platform(multi-select: WeChat/X/Xiaohongshu/Toutiao/Community), H Curiosity(rating 1-5), K Knowledge(rating 1-5), R Resonance(rating 1-5), E Ease(rating 1-5), Recommendation Score(formula: sum of H/K/R/E), Priority(select: P0/P1/P2), Topic Status(select: Candidate/Writing/Published/Dropped)
  · 07 Article Draft Library: Article Title(text), Publish Platform(select), Writing Status(select: Writing/Ready/Published), Doc Link(url), Article Link(url), 24h Engagement(number), 48h Engagement(number), 7d Engagement(number), Review Notes(text)

Step 4 — After each table is created, run base +field-list --base-token <token> --table-id <table_id> to verify all fields are in place.

Step 5 — Write a test record to "01 Daily Material Dashboard" and read it back:
  lark-cli base +record-upsert --base-token <token> --table-id <table_id> --json '{"Today Top Event":"TEST — Content Workbench Setup Successful"}' --as user
  lark-cli base +record-list --base-token <token> --table-id <table_id> --limit 5 --as user

Rules: Keep base_token, table_id, and record IDs local only — never share outside this chat. If you're unsure about rating/formula field types, create them as plain types first and refine later. Finish with a short report: how many tables created, their table_ids, and whether the test record write/read succeeded.

✅ Success checkpoint: Codex reports each table’s table_id, you can see the “AI Content Workbench” database in Lark with all fields matching, and “01 Daily Material Dashboard” contains a record that says “TEST — Content Workbench Setup Successful.” To expand to all 10 tables later, just have Codex keep adding with the same +table-create pattern.

4.3 Install AI HOT — Give Codex Something to Collect Every Day

Tables are useless without a steady stream of input. I use AI HOT (aihot.dev) — a curated Chinese-language AI news source with a public API that requires no API key. Give Codex its skill, and Codex can pull the daily AI digest automatically. This is where my “02 AI HOT Event Database” gets fed:

curl -fsSL https://aihot.dev/skills/install.sh | bash

Once installed, just tell Codex “What happened in AI today?” and it pulls back a curated list. (Small gotcha: if you write your own script to call the /api/public endpoint, you need to include a browser User-Agent header, otherwise you’ll get a 403. The built-in skill handles this automatically.)

4.4 Set It and Forget It — Codex Scheduled Automation

Daily automated: Codex scheduled tasks collecting and writing to Multidimensional Sheets

Daily automation: Codex scheduled tasks scrape and write data into Multidimensional Sheets automatically

You can run everything manually by now. But I didn’t want to do this by hand every day, so I offloaded the collection entirely to Codex’s Automation feature. The Codex desktop app has an Automation panel where you can save a prompt as a scheduled task that runs on its own. Here’s what I have running:

Codex Automation Panel — a row of daily scheduled collection tasks

Nightly Material Scraping — runs at 10:30 PM
Grok Nightly Scrape & X Candidates — runs at 12:00 AM
Self-Growing Knowledge Base Daily Refresh — runs at 8:40 AM
Daily Writing Topic Card — runs on schedule
Rolling Writing Material Collection — runs continuously

Each task is a fixed prompt telling Codex where to scrape, how to organize the data, and which Lark table to write to.

Click into a task: boundaries, steps, validation, and output — all clearly defined

Click into any task: boundaries, steps, success checks, and output requirements — all explicitly defined

How do you create one? Three steps: open the Automation panel in the Codex desktop app, create a new task, paste in your prompt, and set the schedule (daily at a specific time, or custom). The hard part is never which button to click — it’s how you write the prompt. Write it vaguely and it goes off the rails. Write it precisely and it runs like clockwork every day.

I structure every task prompt around four blocks:

① GOAL + BOUNDARIES: What it should do and what it must NEVER do (e.g., "Only collect and organize — never publish directly, never modify table structure, never click any authorization prompts").

② EXECUTION STEPS: Step 1 does this, Step 2 generates that, Step 3 writes to which Lark table. Use actual commands where possible.

③ SUCCESS VALIDATION: What counts as a pass ("Date must match," "At least 5 candidates"). If it fails, state exactly why.

④ OUTPUT REQUIREMENTS: Produce a brief report — how many items scraped, which tables written to, any errors. Keep base_token, table_id, and record IDs local only.

Here’s a ready-to-customize template. Create a new automation task, paste this in, set it to run every morning, and it will automatically collect your daily AI news digest and topics into your Multidimensional Sheets:

Every morning at 8:30 AM, collect the latest AI content materials, organize them, and write them into my Lark Multidimensional Sheets.

BOUNDARIES: Only scrape, organize, and write to Multidimensional Sheets. Never publish to any platform directly. Never modify Lark table structure. Never change any of my other settings. Never click any authorization prompts.

STEPS:
1. Use the AI HOT skill to pull today's AI daily digest and featured events (just say "What happened in AI today?").
2. Before writing, run lark-cli base +field-list to verify the field names in "02 AI HOT Event DB" — do not guess.
3. Write noteworthy events into "02 AI HOT Event DB" using lark-cli base +record-upsert. Align fields: Event Title, Category, Value Rating, Source URL, Summary.
4. Pick 3–5 angles from today's materials that could become articles, and write them into "06 Topic Pool" with initial Curiosity/Knowledge/Resonance/Ease scores.

SUCCESS VALIDATION: At least 1 new record added to the Event DB and at least 1 to the Topic Pool. After writing, read back with +record-list to confirm visibility. If something fails to write, report whether it's a field name mismatch or a permissions issue — do not fake success.

OUTPUT: Brief report — how many daily digest items pulled, how many written to the Event DB, how many candidate topics generated, any errors. Keep base_token, table_id, and record IDs local only.

💡 This is exactly how my pipeline gets fed every day — not by my hand, but by these scheduled tasks that scrape, organize, and write into the Multidimensional Sheets automatically. When I open Lark in the morning, what I see is already a ranked list of candidates, not a blank slate.

Mistakes I’ve Actually Made (So You Don’t Have To)

💡 ① Codex install fails? Check if Node.js is installed first (node --version). ② +table-list returns nothing? Your authorization scope probably didn’t cover the table — go back to the Lark Open Platform and extend permissions. ③ Use the right field types: Status fields → single-select. Dates → date type. Ratings → rating type. Don’t improvise. ④ Don’t be greedy: get 5 tables running smoothly before adding more. ⑤ Never expose base_token, table_id, or record IDs in public articles or posts.

Final Thoughts

I want to end with something important: great articles still require a human writer. Whether a topic is worth pursuing, whether an argument holds up — these are things AI can’t replace. What this system does is simplify your selection and review workflow. But the actual writing, especially hands-on tutorial content, still demands that you walk through the process yourself, take screenshots, analyze results, and show readers the real journey. If you let AI fabricate everything, your audience will fall for it once — and then nobody will read your work again.

This article is a full English translation and SEO/GEO adaptation of a Chinese-language tutorial by Chris Wang (@ChrisWangwy on X), originally published as a Twitter/X thread. The system described uses Lark (Feishu) Multidimensional Sheets with built-in AI capabilities and OpenAI Codex for automation.

How I Built an AI Content Command Center with Lark Multidimensional Sheets: Full Automation Tutorial