Start with a clear structure. A knowledge base is not a random pile of documents. It should be organised into logical sections — policies, product information, how-to guides, and so on — so both humans and AI can find things easily. Good structure makes everything downstream easier.
Write in plain, specific language. AI agents understand clear writing better than vague prose. Avoid jargon where possible, define terms, and write in short, focused paragraphs. If a human would find a document confusing, an AI agent probably will too.

Keep each document focused on one topic. A page that tries to cover ten different things is hard to navigate and hard for an AI to use. Break things up into small, single-purpose documents that answer one question well.

Keep it up to date. The most common reason AI agents give wrong answers is that the knowledge base is stale. Set up a process for reviewing and updating content regularly, and assign someone to own it. Outdated information is worse than no information.

Make it searchable and accessible. The knowledge base needs to be somewhere your AI agents can actually read, whether that is a shared drive, a wiki, or files in a repository. The exact tool matters less than making sure the agent can reliably pull from it.

Finally, test it. Ask your AI agent real questions and see how well it answers. When it gets something wrong, fix the source document, not just the answer. Over time, that feedback loop turns your knowledge base into a genuinely reliable foundation for your agents.

The Metered Brain: A Utility for the Few?

The current trajectory of closed AI models treats intelligence not as an open infrastructure, but as a metered commodity. During an appearance at the BlackRock Infrastructure Summit, OpenAI CEO Sam Altman outlined this corporate vision cleanly:

"We see a future where intelligence is a utility, like electricity or water, and people buy it from us on a meter, and use it for whatever they want to use it for."

While Altman frequently argues that the price of intelligence drops 10x every year, his metered framework introduces a structural risk. If a handful of centralized tech giants control the infrastructure and gatekeep access via proprietary APIs, raw intelligence becomes a luxury asset.

When computing infrastructure lags behind global demand, Altman admits that prices could spike, forcing advanced AI into the hands of the wealthy or under the direction of bureaucratic central planning. This economic model threatens to lock out smaller startups, researchers, and public institutions, leaving only multi-billion-dollar corporations with the capital to pay the "intelligence bill".

The Sovereign Data Crisis

Beyond the pure balance sheet, closed-source models create a massive security flaw for global institutions: the surrender of data sovereignty.

When a nation, a health network, or a defense contractor routes its internal knowledge bases through a centralized corporate API, they lose absolute control over that data. For national governments and highly regulated industries, trusting an external, US-centric corporate black box with critical infrastructure analytics is a non-starter. Walled gardens require organizations to hand over their unique intellectual property just to query the system, turning localized knowledge into training material for future generic corporate models.

Open Weights: The Democratic Counter-Weight

Fortunately, the market is aggressively correcting. Open-weight models are quickly closing the capability gap with closed corporate systems, turning raw intelligence into a true commodity.

Deploying highly capable open-weight models locally offers several massive advantages over centralized APIs:

Absolute Data Sovereignty: Highly sensitive datasets remain fully on-premise, safely contained behind local firewalls without zero-day corporate sandbox leaks.

Zero Token Cost Friction: Organizations bypass volatile, usage-based subscription tiers by running models natively on localized hardware.

Granular Customization: Developers can modify underlying architecture and fine-tune parameters without corporate content moderation filters or arbitrary platform updates.

By treating intelligence as open-source code rather than a metered utility, societies can build localized, resilient digital infrastructure. If frontier labs continue to demand high margins for raw reasoning tokens, they won't just alienate developers—they will force the rest of the world to build an alternative ecosystem entirely out of their reach.

This represents one of the fastest adoption curves the developer community has ever seen. While most people get excited about the actual artificial intelligence "brains," DeepSeek just proved that the "body"—how the AI connects to your computer and actually does work—is what everyone has been waiting for.

What Exactly is an AI "Harness"?

Think of a standard AI model like a brilliant chef who is locked inside a room with no doors, no windows, and no utensils. The chef can give you an incredible recipe, but they cannot actually cook the meal for you.

An AI harness is the kitchen. It gives the AI:

• A digital hands-and-eyes system to look at your files

• A terminal to run software commands

• The ability to coordinate other AI helpers to get a massive project done

Until now, the coolest kitchens belonged to closed systems like Anthropic's Claude Code or SpaceX-backed Cursor. They are incredibly powerful, but you are forced to use their rules, their models, and their pricing. DeepSeek changed the game by releasing their entire agent framework under a fully free, open-source MIT license.

The "Everything is a Plugin" Superpower

The real reason tech communities are losing their minds over DeepSeek Harness is its unique architectural philosophy: Everything is a plugin.

In other AI setups, changing how the AI acts requires rewriting thousands of lines of complex internal code. With DeepSeek Harness, the whole system is built out of Lego blocks.

• Swap the AI Brain: Don't want to use DeepSeek's model? You can use a YAML configuration file to point it at OpenAI, Anthropic, or a completely free model running directly on your laptop.

• Mix and Match: You can actually wire competitor tools like Claude Code right into the harness as a plugin. DeepSeek can act as the manager who delegates specific coding tasks to Claude.

• Self-Improving Agents: The system is so flexible that the AI can actually write and install new plugins for itself while it's running.

Getting It Running Locally

Unlike other developer tools that force you to stay locked inside a boring command terminal, DeepSeek ships with a clean, local Web UI out of the box.

Setting it up takes less than a minute. If you have Node.js installed, you just open your computer terminal and type a single command:

npx @deepseek-ai/dsh web

This instantly boots up a sleek visual dashboard right in your browser at http://127.0.0.1:3080. From there, you get a front-row seat to how your AI is thinking, including real-time token speeds, tool histories, and cost tracking.

A Quick Reality Check

Before you go completely replacing your entire workflow with this new tool, remember that DeepSeek Harness is currently in developer preview (version 0.1).

The creators have openly stated in their official DeepSeek GitHub README that they are iterating rapidly, and future updates will break existing configurations. It has some rough edges, the documentation can be a bit confusing, and it can eat through data quickly if you aren't careful.

Think of it as a thrilling, high-performance concept car. It is the absolute best way to see where the future of software development is heading, but you might want to use it for side experiments before trusting it with your most important production data.

The era of closed-off, rigid AI workflows is officially ending, and DeepSeek just handed the keys of customization back to the open-source community.

After months of hard work, design iterations, and deep-dive development, this platform is finally live to change how you build and interact with user interfaces. If you have ever stared at a clunky admin panel and thought "there has to be a better way," this one is for you.

Why Aspect Themes?

For a long time, I have noticed a massive gap between beautiful website interfaces and functional backend admin areas. Most admin dashboards are either incredibly cluttered or painfully boring to look at. The front end gets all the love, while the tools your team actually uses every day get left behind.

I built Aspect Themes to solve exactly that. It is a dedicated hub for beautifully crafted, highly functional, and fully responsive admin dashboard templates. These themes are built specifically for developers, creators, and businesses who want their behind-the-scenes systems to feel just as premium as their public-facing websites. In plain terms, your admin area should be a joy to use, not a chore.

Built for the Modern Stack

As a developer, I know how frustrating it is to work with bloated, heavy codebases. That is why I built these themes using the tools we actually love to use:

Tailwind CSS Utility-First Design: No messy CSS overrides. Every component is built natively with Tailwind, making customisation incredibly fast and straightforward.

Seamless Node.js Integration: The architecture is fully optimized for Node.js environments, ensuring rapid rendering and smooth backend connectivity.

Native Light & Dark Modes: No lazy color inversions here. Every theme includes meticulously designed light and dark modes that adapt beautifully to user preferences with a single toggle.

Data-Driven Focus: Deeply optimized layouts for complex charts, tables, user management metrics, and comprehensive analytics tracking.

This Is Just the Beginning!

Launching this project is a huge milestone for me, but the real work starts now. I will be continuously adding new template variations, custom components, and specialized framework integrations to the catalog. I have a long list of ideas queued up, and I can't wait to share each one with you.

Go ahead and check out the live marketplace at Aspect Themes. I would absolutely love to hear your thoughts, feedback, or any feature requests you might have!

By pairing OpenCode (an alternative to Claude Code and Codex) with Obsidian (a local-first, Markdown-based knowledge base), you can build a unified, human-readable, and machine-actionable SoT.

When you layer Agentic Driven Development (ADD) on top of this stack, the documentation stops being a passive diary and becomes an active participant in building your software.

The Stack: Git + OpenCode + Obsidian

Using proprietary, siloed tools for project management creates platform lock-in and fragmented context. Here is why the open, local-first combination wins:

• Everything is Markdown: Obsidian stores files as plain Markdown documents. OpenCode projects produce text files. Because everything is text, your code and your documentation can live in the exact same Git repository.

• Bi-Directional Linking: Obsidian’s core strength is linking notes together. You can link a feature request to a specific technical design document, which links directly to local code snippets.

• Version-Controlled Truth: When documentation lives inside your project repository, changes to documentation are tracked via Git commits alongside the code. A feature pull request updates the code and the documentation simultaneously.

Why Agentic Driven Development is the Perfect Match

While Behavior-Driven Development (BDD) is excellent for turning user stories into automated tests, Agentic Driven Development (ADD) is far more appropriate for this specific stack.

ADD views AI agents as autonomous collaborators rather than just autocomplete tools. Agents require structured, highly contextual, and easily readable data to operate effectively. An Obsidian vault hosted on an open repository acts as the perfect cognitive map for an AI agent.

1. The Context Engine for AI Agents

AI agents struggle with massive, disorganized codebases. By structuring your project architecture, business logic, and roadmap inside Obsidian using clear Markdown hierarchies and tags, you create a map the agent can instantly scan. The agent reads your Obsidian notes to understand why a feature is being built before it touches the code.

2. Autonomous Documentation Sync

In an ADD workflow, the agent doesn't just write code; it maintains the SoT. When an agent refactors a backend service, it can autonomously update the corresponding architectural diagrams (using Mermaid.js inside Obsidian) and API endpoints documented in your vault.

3. Executable Roadmaps

With your project source code and Obsidian, your project roadmap is just a text file. An AI agent can parse your Roadmap.md or Todo.md, identify the next highest-priority task, spin up a new git branch, write the code, test it, and submit a pull request—all while updating the task status in your vault

How to Set It Up

1. Initialize a Unified Repo: Create an open-source repository. Inside it, create a /src folder for your code and a /docs folder for your Obsidian vault.

2. Link the Vault: Open the /docs folder as a new vault in Obsidian.

3. Define Agent Prompts: Instruct your development agents (like Cline, Roo Code, or custom LLM scripts) to always check the /docs folder first for context before writing code, and to update those docs when a feature changes.

The Verdict

When your code is open, your documentation is a local-first network of Markdown files, and your primary developer is an AI agent, you eliminate project friction. You no longer write documentation for a dusty corporate wiki; you write it to program your AI agents.

With advanced, low-cost AI models like DeepSeek, a company can build its own basic customer service bots, data analysis tools, and writing assistants. Instead of buying ten different software tools, you route your workflows through one AI system and pay pennies for the actual computing power used. That is a fundamentally different way to think about software.

The Cost Breakdown: SaaS vs. AI

Let's look at a realistic scenario for a mid-sized company with 50 employees using standard tools for copywriting, customer support, and CRM data management.

1. The Traditional SaaS Route

• Average SaaS cost: £40 per user, per month (across 3 essential tools)
• Monthly bill: £2,000
• 6-Month Cost: £12,000
• 12-Month Cost: £24,000

That £24,000 a year buys you convenience, but it also buys you a lot of unused seats, overlapping features, and rising prices every renewal cycle.

2. The DeepSeek AI API Route

Using DeepSeek's highly efficient API models, you only pay for the volume of text generated (measured in tokens). For a team of 50 heavily using AI daily, they might process 100 million tokens a month.

• Average AI data cost: £100 per month
• Internal setup & hosting: £150 per month
• Total monthly bill: £250
• 6-Month Cost: £1,500
• 12-Month Cost: £3,000

The difference is stark: £3,000 instead of £24,000 for the same underlying needs.

The Catch: Upfront Investment

While the operational savings are massive, you must consider the initial setup. You will need to hire a developer or use an agency to build the internal interface for your staff.

If building a custom dashboard costs your company £5,000 upfront:

• Your 6-month savings adjust to £5,500
• Your 12-month savings jump to £16,000

From Year 2 onwards, the software is completely yours, and the ongoing savings go straight to your bottom line. You also avoid the annual price hikes and feature-lock that come with traditional SaaS subscriptions.

Here's what you need to know:

1. Mixture-of-Experts (MoE)

DeepSeek uses Mixture-of-Experts to balance model capacity with computational efficiency.

• Specialized Experts: Each feedforward block is divided into multiple "experts" (e.g., V3: 256 experts). Instead of every token passing through all parameters, only a few top-ranked experts (2–4 per token) are activated by a routing mechanism that scores token embeddings against expert embeddings.
• Routing Mechanism: A sigmoid gating function with learnable expert biases dynamically selects which experts are engaged for each token. This resolves load-imbalance problems common in MoE architectures without adding auxiliary-loss terms.
• Compute Savings: MoE allows DeepSeek to behave like a 671B parameter dense model on training while activating only ~5.5% (37B) of parameters during inference. This reduces both GPU memory usage and runtime costs, enabling long-context capabilities without prohibitive expenditure.
• Shared Experts & Redundancy: Certain popular experts can be duplicated across GPUs in deployment to avoid bottlenecks. This ensures throughput remains high under uneven token distribution.

2. KV Cache and Multi-Head Latent Attention (MLA)

Transformer models rely on storing Key (K) and Value (V) tensors for each token to compute attention efficiently over long contexts—this is the KV cache. For extremely long sequences (e.g., 128K tokens in DeepSeek), naive caching would cause memory usage to skyrocket.

MLA tackles this:

• Low-Rank Compression: Instead of caching all K/V tensors at full precision, DeepSeek projects them into a smaller latent space (c_t), drastically reducing storage (sometimes >90% memory savings).
• Query Compression: Although queries are ephemeral, MLA also compresses them slightly to maintain consistency without burdening cache memory.
• Separation of Content and Position: Rotary Positional Embeddings (RoPE) are applied independent of content representations. Keys are split into a compressed content component and a RoPE-aware positional component, ensuring positional info is preserved while keeping most KV tensors compressed.
• Decompression-on-Demand: During attention computation, latent representations are projected back to full dimensions through a lightweight reconstruction, effectively providing the same representational power at a fraction of the memory cost.
• Inference Impact: MLA enables long-context inference while keeping GPU memory requirements practical. In V3, KV cache memory was reduced by over 93% without degrading quality.

3. Cache Optimization Strategies

DeepSeek’s architectural approach not only compresses KV tensors but complements this with efficient caching strategies:

Absorb vs Naive Modes:

• Naive: Stores all expanded K/V tensors. Highly memory-intensive.
• Absorb: Stores only compressed latent representations, expanding them dynamically when needed. Reduces cache usage by nearly 98–99% in practice.
• Dynamic Context Scaling: For sequences exceeding base context lengths, attention scaling factors and positional embeddings are adjusted to preserve numerical stability while maximizing effective receptive field.

4. Synergy Between MoE and MLA

• Memory-Efficient Activation: Since only a subset of experts is active for every token (MoE), the memory saved by MLA complements this sparse computation, enabling model deployments with both enormous capacity and manageable resource usage.
• Preservation of Model Quality: Unlike grouping heads arbitrarily (e.g., GQA) or quantizing caches aggressively, MLA provides low-rank compression while still allowing attention heads to access distinct representations for diverse heads.
• Scaling to 1T Parameters (V4): With upcoming V4 models, MoE and MLA together permit ultra-high parameter counts (1T) while reducing active parameters per token (32B) and keeping memory and compute costs feasible.

5. Practical Implications

• Fine-Tuning: LoRA-like adapters can be inserted post-training into attention layers to adapt MoE and MLA without retraining the full model, balancing capacity, efficiency, and accuracy.
• High-Context Applications: For tasks like multi-document reasoning or long-session chat, MLA ensures long token histories remain manageable in GPU memory, while MoE delivers computational efficiency.
• Inference Cost: The combination allows DeepSeek to offer API pricing that is significantly lower than dense models of comparable capability while maintaining competitive performance.

These innovations make DeepSeek AI suitable for research, enterprise applications, and long-form reasoning tasks where both speed and context depth are paramount.

What can you realistically expect?

I wanted to build a project that would use enough tokens to realistically benchmark typical usage for a project. As I work for a warehouse and logistics company I decided to build a project that allow users to manage typical equipment found in a warehouse.

I called it EquipIt and you can visit the project on GitHub: (https://github.com/techno-yeti/equipit).

For EquipIt I used less than £2 of tokens, I believe this is due to the above mentioned reasons but mostly hitting the cache.

I wanted to show some screenshots for the EquipIt app to showcase the style and detail the AI came up with. I believe that DeepSeek v4 Pro is usable for commercial use (see project screenshots below):

Planned Requests Dashboard: shows the current requests planned for that day (the day can be changed with the calendar select widget).

Listing All Requests: shows all requests stored in the app (good for planning days and weeks ahead).

Printable Delivery Advice Notes: shows printable delivery advice note for the driver to give to the security gate on exiting the yard, this can only be used once).

Limiting Email Addresses: to stop other companies using the app there is an email restriction function.

There are other features that are not shown here: trailer templating, listing equipment types, user management and the help center.

Conclusion

DeepSeek’s architectural elegance lies in orchestrating sparsity (MoE) and efficient attention caching (MLA) to enable high-parameter, long-context LLMs that remain economically and operationally feasible. By compressing what needs to be stored and sparsifying what needs to be computed, DeepSeek achieves a remarkable balance between scale, speed, and accuracy, representing a state-of-the-art approach to large language model design.

After having launched my own blog and an equipment management web app as practice projects, I'll tell you how to get the most out of your AI assistant.

It all boils down to defining exactly what you want the AI assistant to do. By doing this, the AI is laser focused on the task at hand and you'll no longer have to worry about token burn rate. But what would this look like in practice?

For me, it looks like a set of spec files. Before I let an AI agent anywhere near the code, I write down exactly what the feature should do, how it should behave, and what success looks like. That little bit of upfront effort saves a surprising amount of wasted output later.

I have posted a set of spec files for a MERN-based project on my GitHub account (link can be found above next to my avatar picture). Feel free to edit them for your own projects, and if you would like to, post a link to an update in the comments section below.

Bearing in mind I used this format before I heard of agent skills. The downside is you'll have to change the spec files for each individual project. That is fine when you are working on a handful of things, but it gets repetitive if you juggle many projects.

I've also gotten into the habit of getting the AI model I'm working with to generate a set of spec files in case I wish to regenerate the source code with certain changes (for example if a client decides to go with an alternative CSS framework). I usually include this with the project so that I don't lose context. It means I can rebuild the whole thing from scratch weeks later without having to re-explain everything.

If you're looking for something more generic that can work across multiple projects, then this GitHub repo might be something to test (not created by me):

https://github.com/addyosmani/agent-skills

The key takeaway is simple: give your AI a clear brief and it will reward you with focused, useful work. Skip that step and you will spend far more time (and tokens) cleaning up the mess.

My experience of using AI has always been with using an IDE with it being used as nothing more than code suggestions on steroids. At the time of deciding to use an AI coding tool I also decided to try a new text editor.

After installing Zed I clicked around to get an overall feel of what Zed is capable of and I saw an agent panel indicating that Zed was giving AI agents first class support in their software.

I then signed up for Zed Pro to enable the agents selection panel and decided to use Claude Sonnet as this AI model was recommended by Zed. I saw very quickly that Claude Sonnet was eating up a chunk of money and I looked at other AI models that I thought performed just as good, but were cheaper and that's when I tried Gemini 3.5 Flash.

(see below the pricing table from Zed Industries' website, please note that these prices are now out dated)

For those who have yet to try out AI agents, I would estimate that Gemini 3.5 Flash costs ~£50 per day for 8 hours of continuous use. Bearing in mind users won't be running AI models continuously due to code refactoring and evaluating features, but I think ~£50 per day is acceptable for fair use.

I hope that better frontier AI models will make the likes of Gemini 3.5 Flash cheaper in the future and perhaps even offer capped pricing at 4-6 hours of continuous use for £100 per month.

I guess you're wondering what features I planned for, right? Although I prompted Gemini 3.5 Flash with features, it came up with some interesting implementations:

The first one was a Google SEO Optimizer.

The second one was a cookies banner directly generated from its own CORS code.

The third one was a cover image uploader, which has allowed me to re-use already existing images should I have a long running post series, for example writing a weekly news post.

There were many other features added over time...

You're probably wondering if I would recommend using agentic AI for coding projects...

Yes, but it comes with a couple of caveats, the output code is around 95% useful, meaning the AI agent will write comments very similar to the way humans would, this makes sense if the AI models have been trained on OSS projects being hosted on places like GitHub, also you need to have a good idea of what features your app would need and this can only come from real world experience.

To prevent token overburn I would start off by implementing small projects at first and build up to more complicated projects after you become confident with the tools. 😉

Here I write mostly about my experiences with coding and AI tools.

This blogging software was created solely with agentic AI models. In a later post I describe how I used AI to design and implement this project and the reasons why I chose this method.

If you have yet to dip your toes in Agentic Driven Development then I hope to inspire you to start your own projects.