Running WorkBuddy + DeepSeek for 30 days on an automated content matrix: things aren't that simple

By Ferries

Does anyone else feel that in 2026, the tech community is all in a hurry? Scrolling through the hot feeds, interviewers ask 'When AI can write 80% of the code, what can you still do?' and peers show off 'one person plus AI making 20,000 yuan a month.' I got anxious too, so over the past long holiday I decided to hand my previously manual tech public account entirely to AI and build a 'no human intervention' fully automatic content matrix.

The result: after running for 30 days, the multi-platform fan base grew by 4,000+, I landed two ads, and net profit was 2,100 yuan. Not much money, but this is a system that silently works every day on my old 16GB RAM computer.

This post won't dish out chicken soup; I'll directly share the full-stack technical solutions behind this system and the pitfalls I hit trying to stop AI from making things up.

1. Core requirements and minimal tech selection

My goal was clear: every day at a scheduled time, grab hot projects from GitHub Trending and Hacker News, let AI understand the source code, automatically generate a high-quality technical analysis article with an architecture diagram, and finally distribute it automatically.

If you had done this a year ago, you'd have to write a lot of Python crawlers, API integration code, and complex scheduled scripts. But today, I chose this minimal stack:

• Main brain and orchestration: WorkBuddy. It orchestrates the whole agent flow, using its timer triggers and workflow nodes directly, saving me from writing cron and state machines.
• Local execution and file handling: DeepSeek Harness desktop. This is a recent real artifact. It mounts a local working directory directly, reads and writes Markdown, executes local Python scripts, without needing weird permission configs. Those who know, know.
• Image generation: I attached a local image-generating Skill fine-tuned from Flux, dedicated to geek-style illustrations.

2. Fatal pit: AI's 'context amnesia'

At first, I thought if my prompts were good enough, AI would handle everything. Within less than a week, the system was crashing frequently. Specifically:

1. Cross-project hallucinations: Yesterday it crawled a Vue project, today a React project, and when generating the article, the AI actually forced Vue's reactivity principle into React's code analysis.
2. Extremely homogenized content: Several days in a row, the generated articles all opened with the identical 'With the continuous development of front-end technology...' (Really, I was annoyed by this model's inherent 'eight-legged essay' style.)

The core reason, as the big name who wrote 'Why AI long novels always collapse at chapter 30' in the previous rankings said: during continuous long-running tasks, AI's context pollution is too severe. It simply can't distinguish between current local context and global historical memory.

3. Engineering solution: giving AI a 'memory cleaner' and a micro RAG

To solve this, I didn't obsess over mystical prompt engineering; I used traditional engineering thinking to restructure the workflow.

1. Physically isolate the workspace (based on DeepSeek Harness) I wrote a simple script that, before each task starts, Harness automatically generates an independent folder with the current date timestamp, and puts that day's scraped HTML/source code inside. Each read by Harness only locks onto the current dedicated directory, physically separating yesterday's historical data and cutting off the source of context pollution.

2. Introduce a lightweight local RAG for correction To prevent the AI from rambling when explaining technical terms, I didn't let it search online directly. Instead, I connected a micro RAG in a WorkBuddy node.

The core idea is blunt and simple:

• Store a long-accumulated 'technical term calibration dictionary' locally in SQLite.
• Before asking AI to produce the article, use lightweight vector retrieval to pull the explanations of relevant frontier technical principles, and force them into the System Prompt.

Here's a snippet of the Node script core logic for injecting the knowledge base (I used Cursor's one-click autocomplete; I barely typed any lines myself):

import { LocalVectorDB } from 'workbuddy-tools';
import fs from 'fs';

async function injectContext(dailySourceCode) {
    const db = new LocalVectorDB('./tech_knowledge.db');
    // extract the day's core technical keywords
    const keywords = await analyzeKeywords(dailySourceCode);
    
    let contextStr = "【Please strictly follow the following technical background for analysis, and do not freely extrapolate across frameworks】:\n";
    for (let word of keywords) {
        const doc = await db.similaritySearch(word, 1);
        if(doc.length > 0) contextStr += `${doc[0].text}\n`;
    }
    
    // write the hard-constrained context into Harness's daily working directory
    fs.writeFileSync('./workspace/today_context.md', contextStr);
    return true;
}

4. After running it, reflection: where do programmers end up?

After the system ran fully, every morning I only need to spend 2 minutes on my phone to confirm the article preview pushed by WorkBuddy, and tap 'confirm publish'.

Looking back, the actual hand-written code for this system is less than half of what I normally write while slacking off for half a day. 80% of the base code was generated by Cursor, and the remaining 20% was me using engineering thinking to 'wire up' and 'defuse' between various AI tool chains.

So, since AI is this strong, where exactly is our value as programmers? Through these 30 days of tinkering, I reached a very firm conclusion: the future belongs to those who can 'precisely define problems' and 'design fault-tolerant workflows'.

AI is like an extremely smart, unlimited-compute brain without long-term memory or hands. In 2026, what you need most is no longer the ability to 'hand-write a red-black tree', but:

1. Data engineering ability: know at which step to feed AI what kind of clean data.
2. System architecture thinking: know where AI will hallucinate and crash, and preemptively use code to build fault tolerance and physical isolation.
3. Business closed-loop instincts: assemble various AI tool chains at very low cost into products that solve real pain points, or even generate cash flow.

The era of the pure 'code translator' is indeed fading, but the golden age of the 'super-individual architect' is just beginning.

The full set of WorkBuddy orchestration config nodes and knowledge base scripts are packaged on GitHub; as usual, the link is pinned in the comments. If you run into environment configuration errors, @ me in the feed.