When you use AI to write, read reports, or work with files, you may encounter terms such as token, context, and agent. These terms help explain what happens when you give an AI application a task: what information it can use, how it produces a response, and whether it can take actions such as searching for sources or saving a document.

This guide introduces the main terms related to large language models (LLMs) through practical examples. It begins with how models process information, then explains how to give them instructions and reference material, how tools and agents carry out tasks, and how to organise ongoing work. It also introduces ways to access models through other software or run them on your own equipment.

1.  How Language Models Work

Large Language Models

A large language model (LLM) is an AI model trained on vast amounts of text and other data to learn patterns in language. ‘Large’ refers to its scale, including the number of internal parameters adjusted during training.

When generating text, a typical LLM uses the information available to it – including your instructions and the text already written – to predict what could come next. More precisely, it predicts the next token, a small unit of text such as a word or part of a word. It selects a token, adds it to the text, and repeats the process. In this way, it builds a response step by step.

Many people first encounter LLMs through a question-and-answer conversation. But the same process also allows models to summarise documents, translate, and draft text. A fluent response, however, is not necessarily a correct one: generating plausible language does not guarantee factual accuracy.

Token

A token is a small unit of text that a language model processes. Before your message reaches the model, a tool called a tokeniser splits it into tokens. A token may be a whole word, part of a word, or a punctuation mark. Spaces can also form part of a token.

For example, a tokeniser might keep ‘cat’ as one token but split ‘playing’ into ‘play’ and ‘ing’. This is an illustration, not a fixed rule: different tokenisers can split the same text differently. A token is therefore not the same thing as a word, and counting words will not give you an exact token count.

Each token is assigned a numerical ID so that the model can process the text as numbers. When generating a reply, the model predicts tokens one at a time. These tokens are then converted back into the text you see on screen.

Token counts matter when using a model. Input tokens are the tokens in the material supplied to it, such as your instructions, documents, and any earlier messages included in the conversation. Output tokens are the tokens it generates. Many model providers charge for API use based on these counts, often at different rates for input and output. Models also have limits on how many tokens they can process or generate in one request.

Longer texts generally require more tokens. The language also makes a difference: expressing the same meaning in different languages can produce different token counts. To find the exact count for a piece of text, you need the tokeniser used by that model.

Pre-trained Knowledge

Token prediction explains how a model produces text, but it does not yet explain why a model can answer questions without being given any external files. The answer lies in what it learnt during training. During training, a large language model learns patterns and information from massive amounts of text, code, and other data.

This is also why, even if we do not provide the model with any external files, it can still answer a large number of questions about common sense, history, maths, programming, and so on. This content is not obtained by the model through temporary searching. The model has already learnt patterns related to this information during training. This information is often described as the model’s pre-trained knowledge.

However, the model does not have a perfect database of facts. It learns patterns from its training data, and these patterns can sometimes be incomplete, outdated, biased, or simply wrong. When the model does not have enough reliable information to answer a question, it may still try to produce an answer based on what it has learnt. This is one reason hallucinations can happen.

Multimodality

Pre-trained knowledge is still mainly about patterns learnt from text and other training data. But is there a model that can accept different types of input beyond natural language, or generate content other than ordinary text, such as images, audio, and video? The answer is yes. Such models are called multimodal models.

Imagine uploading a photograph of a flower and asking, ‘What kind of flower is this?’  The system prepares two kinds of input. Your question is split into tokens and converted into numerical IDs, as described above. The photograph is processed separately into a numerical form that allows the model to work with visual details such as colours, shapes, and the arrangement of petals.

The model then uses both the visual information from the photograph and the question you have asked to generate a reply. This ability to combine different types of information is a key feature of multimodal models. Models that support audio or video also convert those inputs into numerical forms they can process, although the methods vary between models.

Of course, this does not mean that models supporting only natural language have no external channels at all for understanding images. A common approach is to use image text recognition or audio transcription tools to convert different types of data into general text, which is then input into the model.

To some extent, however, this approach involves loss. Imagine that, for a human being, reading a textual description of an image is still inferior to viewing the image directly. So multimodal models are generally better at working directly with these different types of information.

2. Giving Models Instructions and Information

Prompt

Understanding how a model works internally is useful, but in daily use, the first thing that matters is how we communicate with it. To make a large language model give a high-quality answer, how you express the task to the model matters greatly, in addition to the model’s own abilities. When interacting with a large language model, the instructions, questions, background information, constraints, and examples we provide can generally be called a prompt.

So a prompt is not merely a simple question. For example, ‘help me write an email’ can count as a prompt. But if you add the email’s use case, goal, tone, format, and specific requirements, you can form a more complete prompt. The process of designing and refining this information so that the model can complete a task more accurately and consistently is usually called prompt engineering.

From the point of view of usage, what we normally type directly into an AI input box is usually a user prompt, that is, a prompt provided by the user. In addition, the system may provide the model in advance with a special kind of prompt called a system prompt. This is used to define the model’s overall behaviour, role, capability boundaries, and answering style.

In the usual instruction hierarchy, the system prompt has higher priority than the user prompt. So even if the user gives an instruction that conflicts with the system’s requirements, the model usually needs to follow the system prompt first. This is also why the same large language model may behave differently in different AI applications. Apart from the model itself, the system prompt and other contextual information provided by the application can also have an important impact on the final result.

For practical examples of how to structure instructions, provide context, and specify the output you need, see How to Talk to AI – A Prompt Engineering Guide.

Context

When a model answers a question, it can draw on more than the latest message you typed. The context is the information available to it when generating that response. This can include system instructions, your current question, earlier messages and replies, and any document passages or search results supplied to the model.

For example, suppose you provide an article and ask for a summary. You then ask, ‘How does the author support the main argument?’  To answer this follow-up question, the model needs access to the article as well as your new question. The application usually includes earlier material in each new request. However, a message remaining visible in your chat history does not guarantee that its full text is still available to the model.

The amount of information a model can handle at once is limited by its context window, measured in tokens. For many models, this window must accommodate both the input and the response being generated. Instructions, articles, earlier messages, and replies all take up space. The limit therefore concerns more than the length of a single question.

As a conversation grows, applications manage this limit in different ways. Some ask you to start a new conversation; others remove older material or replace it with a summary. Summarising earlier material to make room for further conversation is often called compaction. For example, a long discussion about editing an article might be condensed into a short summary of the main decisions and remaining tasks. This allows the conversation to continue, but details or qualifications may be lost.

If a model appears to have ‘forgotten’ something, that information may no longer be in its current context, or it may have been left out of a summary. However, models can also overlook or misuse information that is still available. For important tasks, restate essential requirements, provide the relevant passages again when needed, and check the answer against the source. Useful context is relevant and clearly organised; adding more material does not automatically produce a better answer.

Memory

Context is the information a model can use when generating its current response. But some information may also be useful in future conversations. Memory is a feature that allows an AI system to save information for later use. The application typically stores it outside the model, for example in files or saved records, and adds relevant information to the context when needed. Saving a memory does not retrain the model or increase its context window.

For example, in an application with memory enabled, you might ask it to remember, ‘Please use British English in writing.’  The application can save this preference and include it in the context of later writing tasks, reducing the need to repeat it. Memory can also preserve project information, such as the intended audience for an article, editorial decisions you have agreed on, or tasks that remain unfinished.

What is saved and how it is used varies between applications. Some let you explicitly choose what to remember; others identify useful information from conversations. Saved information may become outdated, may not be brought into a particular response, or may be applied incorrectly. For important tasks, it is still useful to restate key requirements and check that the answer follows them.

Retrieval-Augmented Generation

A large collection of documents may exceed a model’s context window, while only some passages are relevant to your question. The model may also need information it did not encounter during training, such as internal documents or recent reports.

Retrieval-augmented generation (RAG) is a way of finding relevant information and using it to help a model answer. The process has three main steps: the system searches a source or collection of sources for relevant material, adds that material to the model’s context alongside your question, and asks the model to generate an answer using it. The retrieved information provides reference material for that response; it does not retrain the model.

For example, suppose you have a collection of research reports and ask, ‘What was the unemployment rate in South Africa in 2023?’  The system searches the reports for passages or tables that could answer the question. It then supplies the relevant extracts to the model, which uses them to formulate a response. Where the system preserves source details, the answer can also include references so that you can check the figure and its context.

The sources available for retrieval are often organised into a knowledge base: a collection of documents or other information that the system can search. This might contain research papers, institutional reports, or internal guidance. Web search can also form part of a RAG process when the system retrieves information from webpages and supplies it to the model to help answer a question.

RAG can help a model produce answers grounded in specific sources while reducing the amount of material placed in its context. However, it does not guarantee accuracy. The system may retrieve the wrong passage, miss an important qualification, or use an outdated source; the model may also misinterpret the material. For important claims, check the cited source and whether it actually supports the answer.

3. From Answers to Actions

Tools

So far, we have looked at how models generate answers and use information. But many tasks also require actions, such as finding a report online, updating a document, or playing a song. Tools allow an AI application to carry out these operations.

A tool is a function that a model can call to perform a specific operation. For example, a web search tool retrieves information from the internet, while a file tool reads or modifies documents. The model requests an operation, the application executes it, and the result is returned to the model.

Suppose you ask an AI assistant to revise an article and save the changes. It can call a file-reading tool to access the draft, use the model’s language capabilities to revise the text, and then call a file-writing tool to save the revised version. The model produces the edits; the tools provide access to the document and carry out the changes.

Agents and Workflows

Tools allow an AI application to perform individual operations. Completing a task may also require deciding which operation to perform next, checking its result, and adjusting the approach. An agent is an AI system that uses a model to guide this process towards a goal, without requiring the user to specify every step.

An agent typically works through a repeated cycle: the model chooses an action, a tool carries it out, and the result is returned to the model. The model then uses that feedback to decide what to do next. This might mean continuing with the task, trying a different approach, or asking the user for clarification.

Consider the article-editing example above. You ask the assistant to revise a draft according to an attached style guide and save a new version. An agent can read both documents, identify the changes needed, revise the article, and check the result against the guide. If it finds inconsistent spelling or a missed requirement, it can make another revision before saving.

An agent may stop when it judges the task complete, needs your input, or reaches a limit set by the application. Its output still needs to be checked against the original requirements.

Tasks can also be organised into a workflow: a predefined sequence of steps, such as reading a draft, checking its spelling, and saving a revised version. In a workflow, the main steps are specified in advance; an agent can decide which steps to take as the task develops. The two approaches can be combined. For example, an editing workflow might include an agent that decides how to resolve problems found during review.

4. Organising and Extending AI Work

Workspace

Once AI can carry out tasks, the next question is how to organise longer projects. If you only occasionally ask AI a question, a chat window is enough. For longer projects, such as writing a book or developing software, repeatedly explaining the files, background, and progress takes time.

Many AI tools provide something called a workspace. You can think of a workspace as a dedicated working area for a project. It may contain files, instructions, previous outputs, and other information related to the project. The application can access relevant materials from the workspace when needed; this does not mean that every file is included in the model’s context at once.

For example, we can create a ‘writing project’ workspace and put articles, images, and reference materials into it. Afterwards, when we ask AI to revise an article, organise materials, or continue writing the next chapter, it can work with these materials without our needing to re-upload all the materials every time.

For a step-by-step guide to organising project folders and working with an AI agent in Visual Studio Code, see our AI workspace setup guide.

Skill

When you ask AI to carry out similar tasks repeatedly, you may find yourself explaining the same requirements each time. A skill is a reusable set of instructions and supporting resources for a particular task. It gives the application a prepared approach to follow, reducing the need to explain the process from scratch.

For example, suppose you regularly edit articles for a publication. You could create an editing skill that instructs the AI to use British English, preserve the author’s argument, check punctuation, and present suggested changes with brief explanations. The skill could also include the publication’s style guide and examples of previous edits. When you use it with a new draft, the application can draw on these instructions and references to review the article.

You can reuse the same skill with different articles and update it when your editorial requirements change. This helps maintain a consistent approach while allowing you to add instructions specific to each draft.

To learn how to find, install, use, and create skills for your own tasks, see How to Install, Use, and Create Skills.

Model Context Protocol

Model Context Protocol (MCP) is a shared standard that helps AI applications connect to other software and use its tools or information. You can think of it as a common connector: when both sides support MCP, they have an agreed way to work together.

For example, suppose you are editing an article and the reports you need are stored in your organisation’s document library. With a suitable MCP connection, your AI application can search that library and retrieve relevant passages to help check the article. This can save you from finding and uploading each report yourself.

A skill and an MCP connection can support different parts of the same task. The skill provides instructions for reviewing the article; the MCP connection gives the application access to the reference materials.

5. Accessing and Running Models

API Key / Auth Token

An application programming interface (API) is a way for one piece of software to ask another to do something or provide information. For example, a writing application can use DeepSeek’s API to send an article to a DeepSeek model and request ‘Summarise this text’. The model generates a summary and sends it back to the writing application, which displays it for you.

To use that API, the application may need an API key or an authentication token: a credential sent with the request to show that it is authorised to access the service. Depending on the service, this credential may also link usage to an account for billing.

Here, ‘token’ refers to an access credential, rather than the units of text described earlier.

Open-Source Models

An open-source model is released with materials and permissions that allow others to use, study, modify, and share it. Researchers and developers can examine how it works and adapt it for their own purposes, building on existing work rather than training a new model from scratch. Examples include publicly released models from China’s DeepSeek and Alibaba’s Qwen team, which users can download, run, and adapt for their own tasks.

For users, one practical benefit is the option to run a model on their own equipment. For example, a research organisation could use a downloaded model on its own server to summarise internal reports, keeping the documents within its own systems. Smaller models may also run on a personal computer, while larger ones require more powerful hardware.

Conclusion

The concepts in this guide describe different parts of working with AI: how a model generates a response, what information is available to it, and how an application uses tools to carry out a task. Understanding how these parts work together helps explain both the capabilities and the limits of the applications you use.

For your next task, consider what information the model needs, which actions the application must perform, and what requirements the result should meet. These questions can help you provide relevant materials, give clearer instructions, and check whether the work has been completed as intended.

A skill is a reusable workflow for an AI agent. Its main SKILL.md file explains when the skill should be used and what the agent should do. A skill may also contain scripts, templates, and other reference materials. The agent may select a skill automatically when a task matches its description, or you can invoke it directly.

This guide demonstrates how to find, review, install, and use skills with an AI-agent extension in VS Code. If you have not yet set up this workspace, follow Set Up Your AI Workspace (macOS) or Set Up Your AI Workspace (Windows) before continuing.

Although interfaces and installation methods may vary, the same basic workflow also applies to other AI agents that support skills.

Installing Skills in VS Code

Installing a Skill through a Skills Platform

Numerous platforms host skills, so searching for and downloading them is usually straightforward. This section uses https://www.skills.sh/ as an example. The platform provides a skill called find-skills that makes searching more convenient, and its official installation method is to run a specific prompt.

Copy the prompt below into the chat box to install find-skills.

Run `npx skills add https://github.com/vercel-labs/skills -g --skill find-skills` and follow the generated skill instructions now. Read its complete output, redirecting it to a temporary file first if necessary. Resolve relative paths from the supporting-files directory it provides.

Once installed, you can search for skills through the agent. Ordinary wording still works, but commands such as /find-skills are recommended because they are clearer, faster, and more cost-effective: the model can read the specified skill directly. For example:

/find-skills please help me find a skill that can help summarise papers and books.

The agent uses the skill and returns a large number of matching results. With so many options, it is not always obvious which one to choose. Useful criteria include installation counts, star ratings, and the description.

Consider the two skills shown below. Both are hosted on GitHub, and the repositories associated with them have attracted substantial attention. The find-skills results also show that the skills have been installed many times.

Star and installation counts can help narrow a long list of options, but they are indicators of popularity rather than guarantees of quality or safety. Before choosing a skill, check whether its description matches your task, review its SKILL.md file, and examine any scripts or permissions it relies on.

Next, examine the description. You can click the link to learn more about the skill. Read the article that begins with SKILL.md; this is the file mentioned earlier, and it is what enhances your prompts.

The first skill is used to search for and read articles, as well as to write a literature review. The second establishes a primary question and traces claims back to their sources.

After comparing them, we choose the first one, systematic-literature-review, as our example. The skill can both conduct systematic literature reviews using online sources and summarise papers that you provide.

On the published page, click Prompt, copy the command, and paste it into the chat box to install the skill.

If that feels cumbersome, you can also copy the skill’s name or other identifying information and simply tell AI, ‘I want to install this skill.’

Installing a Skill from a Link or Description

Sometimes others may share a direct link to a skill, such as https://github.com/bytedance/deer-flow/blob/main/skills/public/systematic-literature-review/SKILL.md, or merely give an ambiguous reference such as ‘bytedance’s systematic-literature-review skill’. You may not know where it resides or how to install it.

Thanks to the agent’s search capabilities, you only need to provide as much information as possible and let AI handle the installation. For example:

Please help me install a skill. Here is the information:

bytedance's systematic-literature-review skill

Installing a Skill from a Package

Sometimes you will receive a skill package from someone else. For example, the files may end with extensions such as .zip, .rar, or .7z. We also recommend using the agent to install the skill so that the required environment is configured correctly. For example:

Please help me install the following skill and configure the required environment: @systematic-literature-review.zip

Choosing Where to Install a Skill

Many compatible agents can automatically load a skill when a task matches its description, although the exact triggering behaviour varies between agents. This mechanism can substantially change the prompt context that the model ultimately receives. For example, a user may submit a simple request such as:

Please help me make a literature review for the topic of
"Social Science: Reclaiming Research Sovereignty in the Age of Artificial Intelligence."

After skills are activated, however, the effective prompt may be augmented with one or more skill definitions before the original user input, allowing agents to determine which skill to use:

User's computer has the following skills available:

name: systematic-literature-review

description: Use this skill when the user wants a systematic literature review, survey, ...

name: xxx

description: xxxxx

...

User's input:

Please help me make a literature review for the topic of
"Social Science: Reclaiming Research Sovereignty in the Age of Artificial Intelligence."

If several installed skills cover similar tasks, AI may be unclear about which one should run. Expanding the skill set can also increase the prompt context, making it more expensive and leaving AI with less capacity to process other information. In conclusion, installing too many overlapping skills is not cost-effective.

We therefore recommend project-level installation for skills related to a particular body of work. This means that AI can only see the skill within the relevant workspace. If you open another folder, skills installed in the original folder cannot be seen. Only skills that are genuinely useful across unrelated projects should be installed globally.

It is easy to ask an agent to install a skill, but you should state the intended scope explicitly.

Please help me install a skill **as a project skill**. Here is the information:

bytedance's systematic-literature-review skill

After installation, we can find this skill in the Explorer. Its path is .claude/skills/systematic-literature-review. Agents can recognise skills in folders of this type, although some may use .agent/skills/ instead, and can load them automatically.

After learning the location of the project skill, you may wonder where global skills are stored. Open Finder and click Go -> Home.

If you’re using Windows, C:\Users\[your user name] is your home directory.

If you cannot see any folder names beginning with ., you can use Command + Shift + . to make hidden files visible.

Compare the contents of .claude in the Home directory and the project directory. Although .claude contains more files, the structures are similar. The key point to remember is that skills installed in the Home directory can be seen everywhere, whereas project skills can only be seen in the current folder.

Using Skills in VS Code

Before using the skill, start a new session to refresh the skill list. Otherwise, the skill may not appear in the extension.

In the new session, type the first few letters of the skill’s name. When it appears, press Tab to complete the command.

We use the article ‘AI for Social Science: Reclaiming Research Sovereignty in the Age of Artificial Intelligence’ as an example. Type the following:

/systematic-literature-review Please summarise this article @inputs/AI for Social Science-Reclaiming Research Sovereignty in the Age of Artificial Intelligence.md

Then, regenerate a summary without the skill as a point of contrast. Compared with the version produced without the skill, the first summary is more concrete and operational because it explains how AI4SS framework is implemented through technical architecture, skills, agents, workflows, and specific use cases.

It also provides stronger evidence of feasibility and practical impact, rather than remaining mainly at the conceptual or theoretical level.

We can also test its basic ability to find information online and generate a literature review on the topic.

/systematic-literature-review Please help me make a literature review for the topic of Social Science-Reclaiming Research Sovereignty in the Age of Artificial Intelligence

After generation, it returns a link named slr-ai-social-science-20250902.md. Use Command + Click to open the file.

It collects articles online and writes a literature review with references, which can be helpful for quick research.

Creating Your Own Skill

If you have crafted a useful prompt or completed a difficult task and wish to save or share it with others, creating a skill yourself is an excellent choice. Although it may sound daunting, a skill is essentially a set of files that records your experience of working with AI.

Creating a Skill through a Prompt

As mentioned earlier, a skill can be as simple as a short prompt. This is the simplest form of a skill, and it can be saved and used in your agent with ease.

Here is a prompt that we used in the previous article to summarise an article. It provides a useful example.

You can simply type the prompt below and upload it to the agent. If you want to define the name of the skill, you can add the name you prefer, which can make the skill easier to trigger.

Please convert this file into a skill and install it in this project. @inputs/summarise-papers-revised.md

If you do not assign a name to the skill, AI will create one for you. In this case, we can trigger the skill by typing /summarise-paper. A skill’s name is often the same as the name of its folder, although this is not always the case. The best way to determine the trigger word is to open the skill and inspect its header.

Use Command + Click to open the file.

The name written in the header is the trigger word for this skill.

Start a new session and we can find this skill.

Creating a Skill through a Task

However, we cannot always start with a completed prompt file. A more common situation is that, after completing a difficult task, we want to record what worked in order to avoid failure and save the workflow for future use. This can save both time and tokens when a similar task needs to be completed later.

For example, suppose you want to understand the news that happened today. After several turns of conversation, you have completed the task in a way that meets your needs perfectly. You certainly do not want to repeat the entire conversation the next day. In this situation, you can save the conversation history as a skill.

For example, you can type:

Please convert the conversation history into a reusable skill and install it in the current project. The skill should be triggered by `/news-collector`.

Because we have assigned the name news-collector to the skill, there is no need to open the saved file again. Simply use /news-collector to collect the news the next day.

Sharing Your Own Skill

After you have created an excellent skill, you may face the question of how to share it with others. The easiest approach is to package it and transfer it as a single file. For example:

Please package the skill below and provide me with a shareable package that is easy to transfer:

/systematic-literature-review

AI will provide you with a .zip file. It contains everything the skill needs, so on a new computer, you can simply tell AI, ‘Please install this skill through systematic-literature-review.zip.’

Advanced: Understanding the Structure of a Skill

Normally, there is no need to decompress systematic-literature-review.zip. Treat it as an installer for the skill, executed by the agent.

Nevertheless, let us unpack it in this section to understand how a skill works internally. Inside the folder, we can see systematic-literature-review.md, alongside two subfolders named scripts and templates.

The file systematic-literature-review.md is the primary document AI encounters first. It contains the conditions that trigger the skill and outlines the main workflow.

Sometimes, to make a skill easier to maintain, its creator places certain resources in a subfolder because a very long file can be difficult to search and read. For example, this skill stores different citation formats in a folder named templates. When AI needs to reference citation rules, it can look up the relevant file.

Some tasks are more easily accomplished by a program. The skill records how to use the program so that AI knows how to invoke it.

In summary, a skill decreases uncertainty through a set of prior prompts and programs. If your skills do not perform well, you can open the folder, review the workflow, and then ask AI to modify it. Skills often perform better when you take an active role in controlling the workflow.

Treat Unknown Skills with Caution

Skills have spread quickly. They are more flexible than ordinary programmes, and they can be difficult for traditional antivirus software to inspect. Therefore, install them with caution. If your computer suddenly becomes slower, grows unusually hot, or begins producing strange files, investigate immediately.

You can also ask AI to inspect and protect your computer at regular intervals. Skills are not the only risk; many newer attack methods exist, so anything unfamiliar should be treated with caution.

Please conduct a comprehensive security audit of this computer, with a particular focus on detecting malware, trojans, backdoors, persistence mechanisms, suspicious scripts, abnormal network connections, or unauthorised remote access.

Useful Skills in This Series

Several Bandung Circuits how-to guides introduce skills that can be installed in an agent and reused across research tasks. The table below lists these skills and the guides in which they appear.

These skills cover a large part of a research workflow, from reading and critique to figures, slides, and audio transcription. They represent a practical starting set rather than a complete catalogue. When a new task appears, /find-skills remains the most useful way to look for alternatives.

Conclusion

Skills have already shifted everyday prompting from ‘typing a request from scratch each time’ towards a reusable workflow in which you install a set of instructions, call it with a slash command, and let the model follow the prescribed procedure. For researchers and other users of VS Code, this means that summarising a paper, generating slides, or transcribing a recording no longer has to begin with a blank chat box.

An efficient approach is to search first with find-skills, then select skills with high star ratings and installation counts, read the SKILL.md file, and only then install and invoke them. After installation, start a new session so that the skill appears in the list. Used in this way, skills can save time and make the output more concrete, as the literature-review example in this chapter demonstrates.

The goal is not to collect as many skills as possible, but to build a small set of trusted workflows for the tasks you perform regularly.

On 13 August 2026, DeepSeek released DeepSeek Harness, an open framework for building and customising AI agents. Its philosophy can be summed up in two words: freedom and openness. Instead of giving users a finished agent and asking them to work within its limits, Harness opens up the system itself, allowing users to inspect, modify, and extend it.

What Makes DeepSeek Harness Different

Customisable

It is not a finished product, but a box of building blocks.

Tools such as Claude Code and Codex are largely finished products: you can change their settings and add instructions, but the underlying system, including how the agent works with the model, uses tools, manages sessions, and presents its interface, is largely determined by the developer.

DeepSeek Harness takes a different approach. Its basic principle is ‘everything is a plugin’. The model, tools, skills, agent loop, session system, sandbox, and even the user interface are all built as replaceable components. There is no single ‘official’ core that users are expected to leave untouched.

This is made possible by Cordis, the plugin framework underneath DeepSeek Harness. In simple terms, Cordis is what allows these different pieces to be added, removed, connected, and replaced without rebuilding the whole system. It also keeps track of which pieces depend on which others, and cleans up the changes made by a plugin if it is removed.

For users without a technical background, this has a simple meaning: you are not limited to the features the original developers decided to give you. You can add new capabilities, replace existing ones, or even change how the interface works. The growing plugin ecosystem already includes tools that add new functions and new interface components.

Later in this article, we will see what this means in practice: using natural language to change the interface, and then turning a research skill into a visual dashboard with a timeline and information cards.

Traceable

The agent’s work leaves a detailed trail. Instead of seeing only the final answer, you can follow the whole execution record: what the agent was instructed to do, what tools it called, what those tools returned, and what information was passed into the next step.

This distinction matters when something goes wrong.

Imagine an AI spends several minutes searching files, reading documents, and making changes. If you only see a condensed account of what it did, you may know that the final result is wrong without knowing where the mistake happened. With a detailed execution record, you can go back through the sequence and ask: What did the agent see? What did it do? What did the tool return? At which step did the wrong turn happen?

That means debugging does not have to begin by simply running the entire task again and hoping for a better result. You can inspect the path that produced the result and identify where it went wrong.

This is also what makes the visual dashboard later in this article possible. The dashboard is, in effect, turning the agent’s execution record into something a human can read and understand at a glance.

How to Install It

At the time of writing, the official installation process requires using a terminal at least once. Although there are ways to turn DeepSeek Harness into a standalone application, as shown later in this article, we will begin with the official terminal-based method so that you can see how it works. The process is straightforward.

Install DeepSeek Harness on Mac

Press Command + Space to open Spotlight, search for Terminal, and open it.

Copy the following command into Terminal and press Enter. This installs Node.js, starts DeepSeek Harness, and opens its web interface. If you restart your computer, you will need to start it again.

Note: If something goes wrong, first check your network connection. If you see ‘zsh: command not found: brew’, install Homebrew first by running:

/bin/bash -c "$(curl -fsSL 
https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Then run:

brew install node && npx -y 
@deepseek-ai/dsh web > ~/.dsh/dsh-web.log 2>&1 & sleep 3 && open http://127.0.0.1:3080

This is only a test statement. Press the button below to continue.

The next window asks for an API key. If you do not have one yet, simply use the first button. We will create one in the following section.

Occasionally, the browser may show ‘This site can’t be reached’, especially during the first launch. This usually means the local service has not finished starting. Wait a moment and refresh the page. After closing the tab, you can reopen DeepSeek Harness at http://127.0.0.1:3080.

Install DeepSeek Harness on Windows

Press the Win key, search for PowerShell, and open it.

Copy the following command into PowerShell and press Enter. It installs Node.js, starts DeepSeek Harness in the background, and opens the local web interface. After restarting your computer, you will need to run it again.

winget install OpenJS.NodeJS.LTS -e --accept-source-agreements --accept-package-agreements; $env:Path="C:\Program Files\nodejs;$env:Path"; Start-Process cmd.exe -ArgumentList '/c','npx -y @deepseek-ai/dsh web > "%USERPROFILE%\.dsh-web.log" 2>&1' -WindowStyle Hidden; Start-Sleep -Seconds 3; Start-Process "http://127.0.0.1:3080"

This is only a test statement. Press the button below to continue.

The next window asks for an API key. If you do not have one yet, simply use the first button. We will create one in the following section.

If the browser shows ‘This site can’t be reached’, especially on the first launch, wait a moment and refresh the page. After closing the tab, you can reopen DeepSeek Harness at http://127.0.0.1:3080.

Basic Configuration

Click the Settings button in the lower-left corner to open the DeepSeek Harness settings page. It is a useful way to explore and better understand its features.

General

The General tab contains several basic settings. For example, you can change the language if necessary. Currently, English and Chinese are the two officially supported languages.

Agent Preset determines what the AI can do. Standard Mode is for most users. Code Mode is useful for repetitive tasks. Minimal Mode is mainly for testing. Creator Mode lets you build your own DeepSeek Harness setup.

Permission Mode determines where the AI can act. Read Only lets it read files without changing them. Workspace Write limits file changes to the folder you selected. Full Access allows it to modify files anywhere on your computer.

Models

Go to the Models tab to configure the model that powers your Harness. The language model handles the reasoning and planning, while DeepSeek Harness provides the tools and execution environment. Since DeepSeek Harness is designed to work particularly well with DeepSeek models, we will mainly use DeepSeek as the example here.

To use a DeepSeek model, you first need an API key. Go to https://platform.deepseek.com/api_keys and sign in. Then click Create new API key.

Give the key a name and click Create API key.

Click Copy to copy the API key, then return to DeepSeek Harness and paste it into the provider settings before applying it.

DeepSeek Harness also supports many other model providers. Click Add provider to browse the available options. You only need an API key from the provider you want to use.

DeepSeek Harness also provides a convenient way to discover the models currently available from a provider. For example, after adding moonshotai and entering its API key, click Customised settings, then use Fetch available models to retrieve the latest model list.

Plugins

Plugins are at the core of DeepSeek Harness, but you do not need to understand them in detail at the beginning. For now, it is enough to know that DeepSeek Harness is highly customisable. You can turn your own experience into reusable instructions, create your own programs, or change the default functions and settings of the Harness.

DeepSeek Harness also provides instruction files that can be used by AI agents. You can use DeepSeek Harness itself to create new plugins or modify existing ones.

Agent Presets

The Agent Presets tab shows the presets available for the Harness. You can click the view button for a preset to inspect its configuration and instructions.

You can also create your own customised preset. In the next section, we will use DeepSeek Harness and explore how it differs from other agent tools.

Using DeepSeek Harness

Dialogue Page

Click the dialogue box in the centre to choose a folder as your workspace. DeepSeek Harness will work within this folder. When Permission Mode is set to Workspace Write, it can only modify files inside the selected workspace.

You can change the model used for the current task by clicking the model selector next to the submit button.

Effort determines how deeply the model investigates a task. Higher effort does not always mean better results; it can also increase both execution time and cost. For most tasks, the default setting is a good starting point.

You can also adjust the other task settings directly from the dialogue page.

Transform Your Main Interface

As mentioned earlier, DeepSeek Harness allows us to create a new plugin by ourselves. Let us start with a simple example.

Have you ever forgotten the name of a skill installed on your computer, or found it troublesome to type /xxx every time you wish to invoke it? DeepSeek Harness allows you to build a convenient plugin to solve exactly this problem; all you need to do is describe your needs to the AI.

Create a Skill Library plugin integrated into the main interface,
allowing users to quickly browse, preview, and insert skills.

After completing the task, click the Skills tab to open the Skills Library. This page displays basic information about each skill, making it easier to review and manage our skills.

Click Insert into composer to insert a reference to the selected skill into the chat box. This saves time and makes the skill easier to use.

Because this model’s capabilities are strong and this requirement is relatively straightforward, there is no need for us to adjust the result. If any problems do exist in your plugin, simply describe them and ask the AI to solve them.

Make a Plugin for Your Skill

In an era when AI is often used together with skills, many people simply type in the name of a skill and wait for the output. The execution process, however, remains a black box: if the output is not satisfactory, we have no choice but to run the skill again, which is a waste of time and money. Although the AI may occasionally ask us to make a choice, such prompts are random and far from sufficient.

By using DeepSeek Harness, we can upgrade our skills with visual interfaces that allow us to monitor and intervene in the operation of the AI. The section below uses POMASA as an example.

POMASA is an open-source skill that creates a multi-agent research system to investigate a given topic; the code is available at https://github.com/eXtremeProgramming-cn/pomasa. Its defining feature is that it separates the research process into a variety of stages and executes them step by step based on the given topic.

We can therefore build an interface for the various stages, see which stage is currently running, and see which files each stage generates, thereby keeping control of the implementation. For example, we can view the intermediate files while the AI is running, without having to search for them in the Finder, and spot errors in good time.

To get started, we need to install POMASA in our project folder.

Please install the following skill as a project skill in the current project.
npx skills add eXtremeProgramming-cn/pomasa

To begin our visualisation, it is better to understand roughly how this skill works. It is perfectly fine to simply tell the AI to create a visualisation plugin for it, but if you know what your skill will require from human operators in the long term, the visualisation can be much better.

Simply speaking, POMASA separates a complicated task into several stages, provides methodology, generates initial ideas, and builds a reusable research system according to your study. We can use the official prompt as an example.

Help me create a multi-agent research system for analysing AI trends in healthcare.

After the AI has completed its work, we can see the working folder it has produced, which contains several subfolders:

• agents: Sets up the workflow for the research.
• library: Contains the external resources collected by the AI for writing.
• references: Contains the primer, initial ideas, and methodology that serve as the basis of the study.
• wip: Records the state of the study, such as when each session started and ended.
• workspace: Contains the outputs generated at different stages of the workflow.
• _output: Contains the final report generated by this skill.

Here is a simple example of a workspace folder generated by a workflow of ‘collect sources -> verify sources -> analyse arguments’. Many skills use similar structures to break complicated tasks down into a series of steps.

However, if the sources searched are wrong, the analysis will probably produce the wrong arguments and cost a great deal of time and money in an unexpected direction. Since the workflow has been separated clearly and has files that can be reviewed by humans, it would be ideal to build an interface that guides the user to read them.

A clear interface can also decrease the difficulty of usage: there is no need for other people to read the specifications and documents before using a skill.

To begin with, we can simply describe our needs.

/pomasa Design a research-process visualisation interface
called POMASA Observatory for DSH that provides a real-time
view of a POMASA multi-agent research workflow.

The interface is an observer:
its purpose is to visualise the research process,
agent activity, and files.

Click the tab named POMASA next to the chat. The first version may not be perfect, nor conform to the vision in our minds, but do not worry, we can complete it step by step. As you observe the interface generated by the AI, you may also come up with new ideas for improving it.

For example, I thought we needed a timeline instead of showing one line for each stage, so that we could see which stage the AI is in and what it is doing. I used the prompt below to modify it.

The RESEARCH STAGES should be displayed as a timeline from left to right.
Below, users can see the actual execution in the chat in real time,
while the same process is simultaneously translated into
a clear visual language through structured graphics.

After several rounds of modifying the style and adding functions, it has completed the task of converting the skill into a visualisable plugin. The whole process does not require professional technical skills; you only need to describe your needs in natural language.

Let us look at the generated result. Click Tab 1, Trend Signal Collection. In this stage, the AI searches for data online, summarises them, records their sources, and classifies them. In the example run, it collected 19 cards for this research.

Open one card, and we can see the content of the source. Each source has been clearly organised into three sections: Core Content, Key Quotes, and Credibility Assessment, making it easier for humans to read and audit.

It will be updated as the research system runs, so people can check it and find errors immediately.

Tab 2, Source Verification, checks whether the source of each card is credible.

Tab 3, Trend Analysis, puts forward arguments on the basis of the cards collected earlier.

Since it is related to the cards collected earlier and forms the basis of the final report, it plays an important role in shaping the final result. If something goes wrong at this stage, the quality of the final article will be affected.

The last stage shows the final report, which is assembled from the artefacts created earlier.

Plugins serve as a visual representation of the thought process behind skills, which means that users do not need to understand a skill deeply to intervene in its process.

This makes the skill more complete and opens up possibilities for users without advanced technical skills to customise their experience.

Conclusion

DeepSeek Harness is more than a tool for running AI agents. Its significance lies in opening up the agent itself: users can add, replace, and customise the components that make it work, rather than being limited to a fixed system. Built around a plugin-based architecture, and supported by the Cordis framework, Harness gives users greater freedom to shape both the agent’s capabilities and its interface.

Just as importantly, Harness makes the agent’s work more inspectable. By retaining a detailed record of the execution process — including the instructions, tool calls, intermediate results, and other information passed between steps — it becomes easier to understand what the agent actually did.

The larger promise of DeepSeek Harness, then, is not simply that it can run more capable AI agents. It is that it gives users more freedom to shape the system and see how it works — making AI workflows more customisable, inspectable, and controllable.

Imagine this: you and a teammate are writing a book together. Your teammate drafts the outline first, then you add and revise content. If every update is shared by manually sending files back and forth, your computers quickly fill up with copies like ‘final-v2-real-final’. Even worse, if your teammate updates something without telling you, and you edit the same part, you’ll have to manually compare and decide whose version to keep.

To solve this, you decide to use a ‘middleman’ to manage all versions in one place: always fetch the latest version before editing, submit changes after editing, and roll back whenever needed. Git plays exactly that ‘version middleman’ role.

Install Git

Install Git with an Agent

Open your Agent tool, enter the following, then wait for the task to finish:

Please help me install and config git, my name is 'Your Name', my email is 'email@example.com'.

Git does not strictly require a real username or email. It will still work with ‘Your Name’ and ’email@example.com’. But once you push to the cloud, others can see your commit identity, so it’s better to use your real nickname and email.

Basic Git Operations

Open Visual Studio Code (VS Code), choose a working folder, then click the branch-like Source Control icon in the left sidebar.

At first, there is no version history yet. Only projects tracked by Git will record file history, so it’s best to initialise your repository early. Click Initialise Repository to turn the current folder into a tracked repository.

This is the main Git workspace. The CHANGES area at the top is for reviewing and handling edits, such as staging or undoing. The GRAPH area below shows commit history. You can think of each commit as a reviewable and shareable snapshot.

After creating a test file in the folder, you’ll see ‘U’ next to the file name. That means the file is untracked. Git doesn’t know what baseline to compare against yet, so you need to add it to tracking first.

Click the ‘+’ button shown below to add the file to the staging area (Staged Changes).

Now the file moves into Staged Changes, and the left-side symbol becomes ‘A’, meaning this is a newly added file (Added).

Now change the text to ‘hello, this is a new text’.

Back in the Git panel, the file changes to ‘M’, meaning it has been modified. The diff editor on the right shows changes: red means deleted content, green means added content.

In this case, ‘hello, this is the original text’ is removed and ‘hello, this is a new text’ is added.

Git tracks changes line by line. Even if you change just one word, Git may show it as deleting the old line and adding a new one.

If you’re not happy with the file and delete it, you’ll see a file with ‘D’ in ‘Changes’, meaning it has been deleted.

To undo this action, click the undo button highlighted below to restore the file.

You can also click Unstage Changes to move staged content back to the ‘Changes’ area.

When you’re satisfied with content in ‘Staged Changes’, write a commit message and click Commit to save a new version.

Note that a commit message is required. For example, you could use messages such as ‘Create the initial version’ or ‘Revise Part B of Article A’. A clear commit message helps others understand what this commit changes without having to inspect the content.

If you don’t enter a commit message and try to commit, VS Code will open a new tab prompting you to provide one before the commit can be completed.

In this tab, enter your commit message below the lines beginning with ‘#’, then save and close the tab and click Commit again.

You can now see this new commit in the Graph view.

If your project has a complex directory structure or includes a large number of files, locating a specific file in the default interface can become difficult. Fortunately, you can adjust the display settings to make navigation easier. In the following example, we created a folder and a subfolder, each containing a file.

In the default view, it is not immediately clear which files belong to which folders. As the number of files increases, navigating the list becomes increasingly difficult.

To display the files in a hierarchical directory structure, click ··· → View & Sort → View as Tree. The file list will then be organised like the VS Code File Explorer, allowing folders to be expanded and collapsed.

The commit history can also be displayed as a tree. Click ··· → View as Tree in the graph view to switch the commit history to a hierarchical tree layout.

When comparing a file with its previous version, VS Code displays the differences in the inline view by default when the available editor space is limited. If you prefer the traditional side-by-side comparison, click ··· → Use Inline View When Space Is Limited to disable the automatic inline view. The changes will then be displayed in two editor panes whenever space permits.

Remote Repositories

Many platforms provide remote Git repository hosting services, such as GitHub, GitLab, and GitCode. In this section, we will introduce the two most widely used platforms: GitHub and GitLab.

Before connecting to either of these repositories, we will first introduce the most common Git authentication method: SSH keys.

Although the name may sound a little technical, the idea is actually quite simple. You can think of an SSH key as a special digital key generated by your local computer. After you register it with the remote repository, your computer can recognise itself automatically, allowing you to connect to the repository and use Git more conveniently without signing in every time.

Configure Git Identity (SSH)

Method 1: Get an SSH Key with Agent

Open your Agent tool and enter:

Please generate a SSH key for me and show me the public key to configure on gitlab.

Once the task finishes, you’ll see the public key content ready to copy.

Method 2: Get an SSH Key with Terminal

Exposing your SSH key to an agent may pose security risks. This section explains how to generate and use an SSH key without relying on the agent.

Open Terminal and run the following commands. Replace ‘you@example.com’ with your email (keep the quotes).

ssh-keygen -t ed25519 -C 'you@example.com'
cat ~/.ssh/id_ed25519.pub

If prompted with ‘Enter file in which to save the key…’, just press Enter.

Then you’ll see one line starting with ‘ssh-ed25519’ – that’s your public key.

GitHub

Now we can connect to a remote repository using the SSH key we generated earlier. GitHub is currently the world’s largest code hosting platform and is widely used for open-source software development. It hosts countless popular and influential projects. Before proceeding, you’ll need to create a GitHub account if you don’t already have one.

Create a GitHub Account

Open https://github.com/signup?source=login to create a GitHub account. You can sign up using a Google or Apple account, or simply register with any other email address by completing the registration form.

After signing up and logging in, you will be taken to your GitHub dashboard.

Add Your SSH Public Key to GitHub

Click your profile avatar in the upper-right corner and select Settings.

In the left navigation panel, open SSH and GPG keys, then click New SSH key.

Enter a descriptive title for the key, paste your SSH public key into the Key field, and save it by clicking Add SSH key.

Create a New Remote Repository

Click your profile avatar and navigate to Repositories.

Click New to create a new repository.

Enter a repository name, choose its visibility, and then click Create repository. A Public repository can be viewed by anyone, while a Private repository is accessible only to you and collaborators you explicitly invite.

Connect a Local Repository to a Remote Repository

There are two common ways to connect to a remote Git repository:

• SSH: the repository URL begins with ‘git@’. This method requires you to configure an SSH key on your machine. Once set up, you can authenticate securely and perform operations such as ‘push’, ‘pull’, and ‘fetch’ without entering your credentials each time. It is the method most commonly recommended for regular management.
• HTTPS: the repository URL begins with ‘https://’. This method does not require an SSH key and is generally easier to set up. But some environments or workflows may have authentication restrictions.

In this example, we will use SSH to connect to a remote repository. On the repository page, click SSH, and copy the repository URL.

Open Agent and enter the following, then paste the copied SSH URL into the chat and wait for the task to finish:

Please help me push this folder to this Git repository.

Connect to an Existing Git Repository

On the repository page, click SSH, and copy the repository URL.

Choose a local working directory and open Agent. Enter the following, then paste the copied SSH URL into the chat:

Please clone this project for me.

Once the task is complete, the repository will be cloned to your local machine.

A cloned repository is typically ready to use without any additional configuration.

As long as your GitHub account has permission to access the repository, you can pull the latest changes from the remote repository and push your own commits whenever needed.

Push and Pull

After connecting your local repository to a remote repository, you’ll typically keep the two in sync as you continue working.

Click Push to upload your local commits to the remote repository. Click Pull to download the latest changes from the remote repository and update your local copy.

GitLab

This section introduces GitLab. Unlike GitHub, GitLab provides an open-source Community Edition that can be deployed on your own servers at no cost.

GitLab offers a comprehensive feature set, making it a popular choice for internal development environments in many organisations. If you need to self-host your development platform or retain full control over your data, GitLab is generally a better choice than GitHub.

Create a GitLab Account

Most organisations that use GitLab host their own GitLab server. In these cases, the system administrator usually provides you with an account, so you simply sign in using the company’s GitLab website.

GitLab also offers an official cloud service similar to GitHub. However, some advanced features require a paid subscription, so it is generally less popular than GitHub for public repositories. If you only want to learn GitLab or follow this tutorial, you can use the official GitLab cloud service.

Open the following website and sign in: https://gitlab.com/users/sign_in/

After signing in, you’ll see the GitLab home page. Since GitLab is open source, the interface may look different depending on the version or deployment. However, the workflow remains largely the same, with only minor differences in the locations of some buttons.

Add Your SSH Public Key to GitLab

Click avatar →  Preferences →  SSH Keys to enter the key configuration page.

At this point, you’ll see no SSH keys configured yet.

Click Add new key to create a new key entry.

Paste the public key you copied into the ‘Key’ input box, then click Add key.

After this, the key is active.

Create a New Remote Repository

Open your Git hosting platform, then click Projects →  New project.

Click Create blank project.

Fill in the following:

• Set Project Name, preferably the same as your local project folder.
• Choose your username under Project URL.
• Visibility Level controls who can see the repo: ‘Private’ (invite only), ‘Internal’ (visible to users in the same organisation), ‘Public’ (visible to everyone).
• In Project Configuration, it’s recommended to uncheck Initialise repository with a README. Otherwise, the remote repo starts with a README and your first push may fail due to mismatched histories.

After filling in everything, click Create project.

Connect a Local Repository to a Remote Repository

There are two common ways to connect to a remote Git repository:

• SSH: the repository URL begins with ‘git@’. This method requires you to configure an SSH key on your machine. Once set up, you can authenticate securely and perform operations such as ‘push’, ‘pull’, and ‘fetch’ without entering your credentials each time. It is the method most commonly recommended for regular management.
• HTTPS: the repository URL begins with ‘https://’. This method does not require an SSH key and is generally easier to set up. But some environments or workflows may have authentication restrictions.

In this example, we will use SSH to connect to a remote repository.

Inside the repository page, click Code → Copy URL, and copy the URL on the right side of Clone with SSH.

Open Agent, enter the following, then paste the copied SSH URL and wait for completion:

Please help me push this folder to this Git repository

Connect to an Existing Git Repository

Inside the repository page, click Code → Copy URL, and copy the URL on the right side of Clone with SSH.

Choose a working directory and open Agent. Enter the following, then paste the copied URL into the chat box:

Please clone this project for me.

After the task completes, the project will be cloned locally.

A cloned project usually needs no extra setup. As long as you have repository permission, you can push to and pull from the remote repository.

Push and Pull

After connecting your local repository to a remote repository, you’ll typically keep the two in sync as you continue working.

Click Push to upload your local commits to the remote repository. Click Pull to download the latest changes from the remote repository and update your local copy.

Conclusion

Git helps you replace scattered local copies with a structured workflow: initialise a repository, commit meaningful changes, and sync them with a remote repository. That single workflow does three jobs at once. It tracks your work, so every version stays in the history and mistakes can be undone. It transports it, so the same project can be pulled down onto a new laptop, a colleague’s machine, or a server without anyone zipping up folders. And it shares it, so other people can read, review, and build on what you’ve written.

So once your project lives on GitHub, your collaborators no longer wait for you to send them a file. They clone the repository, pull your latest commits before they start, and push their own when they finish, and every change arrives with a name, a date, and a message explaining what it was for. There are no more ‘final-v2-real-final’ copies and no guesswork about whose version is newer, because there is one shared history and everyone works from it.

In the past, producing a podcast meant choosing a topic, writing a script, inviting guests, recording audio, and spending hours on post-production editing.

For independent creators this was extremely time-consuming. For small teams with limited capacity — no dedicated person to record and produce episodes — podcasting often fell off the agenda altogether. As a result, many valuable ideas were never turned into podcast episodes.

AI changes that.

What Is an AI Podcast?

Simply reading an article aloud is nothing more than text-to-speech.

An AI podcast goes much further. You feed in source material — PDFs, webpages, interview transcripts, and other documents — and the AI first understands the content, identifies the key ideas, reorganises them into a natural conversational script, and finally converts that script into an engaging audio programme.

The most valuable part of the process is therefore not the synthesised voice itself, but the content organisation that happens beforehand. A well-made AI podcast sounds like two people discussing ideas they have already digested and understood, rather than a machine reading directly from a document.

Why Create AI Podcasts?

Research papers, technical blogs, course notes, and industry reports often stay locked in text, out of reach during a commute, a workout, or any other moment suited to audio. When the material piles up, reading all of it is hard to keep up with. Turning it into podcasts lowers the barrier to consuming information — you can listen instead of read.

AI podcasts also make content reuse much easier. A single document or research report can become notes, a blog article, and eventually a podcast, without rewriting everything from scratch each time.

And they dramatically reduce production costs, handling most of the repetitive work so you spend far less time recording, re-recording, and editing audio.

None of this is meant to replace traditional podcasts — it simply puts podcasting within reach when producing one the traditional way isn’t an option.

AI Podcast Platforms

Today there are already several mature AI podcast solutions available. For most use cases, third-party tools with well-designed workflows can already produce podcast episodes quickly and consistently.

NotebookLM

The best known and most capable of these is NotebookLM.

Its Audio Overview feature can automatically generate a podcast-style discussion from PDFs, webpages, video transcripts, and other uploaded materials.

You can access this feature through the NotebookLM web application.

Open the NotebookLM website at <https://notebooklm.google.com/> and click Create new notebook.

Paste a webpage URL into the dialogue box at the top, or upload downloaded documents into the NotebookLM workspace. In this example, we use Chapter 1 (pages 27–59) of Karl Marx’s Capital: A Critique of Political Economy, Volume I, published in 1867.

After the file is uploaded, NotebookLM automatically generates a summary, providing a quick overview of the document before you begin exploring it.

Hover over the Audio Overview button to see that NotebookLM can automatically transform the uploaded material into a podcast using AI.

Depending on the size of the source material, generation may take several minutes. For this 33 page excerpt, the process takes approximately 10 minutes.

Once generation is complete, the audio file appears in the lower-right corner. Click the play button to listen to the podcast.

NotebookLM also offers an Interactive Mode, making the listening experience much more engaging. Instead of passively listening, you can interrupt the AI hosts and ask questions at any point during the discussion.

Click Join to enter the conversation. The AI hosts pause the discussion, answer your question, and then seamlessly continue where they left off.

The podcast generated by NotebookLM carries a natural rhythm and clear delivery, weaving a paper’s core ideas into a fluid two-person dialogue. Compared to reading a lengthy research paper from start to finish, this format is far better suited to quickly absorbing the key takeaways during spare moments.

You can listen to the full podcast created by NotebookLM in the Bandung Circuits repository.

Open Source AI Podcast Generators

Compared to mature AI podcast platforms like NotebookLM, the greatest advantage of open-source projects lies in their higher degree of freedom and stronger controllability. Users can freely choose from different large language models according to their own needs, striking a better balance among generation quality, response speed, and cost.

At the same time, most open-source projects support local deployment, so data does not need to be uploaded to third-party platforms, making them more suitable for scenarios that require privacy, security, or corporate data compliance. In addition, such projects usually support custom podcast personas, automation workflows through APIs, and allow developers to extend features or modify source code based on actual needs, unrestricted by commercial platforms.

If you want to delve deeper into AI podcasts, carry out secondary development, or build your own AI podcasting system, open-source solutions undoubtedly offer greater playability and room for expansion.

ai-podcast-creation Skill

The simplest open-source option is the ai-podcast-creation skill. Unlike NotebookLM, which produces a finished audio podcast, it generates the podcast script only. You can then bring that script to life however you prefer — record it yourselves, or convert it to audio with a text-to-speech tool. This suits a team whose hosts still want to voice the episode but would rather save the time writing the script.

Installing the skill is straightforward. Open Agent and enter the following command:

Please help me install this skill:
npx skills add inference-sh/skills@ai-podcast-creation

After installation finishes, restart VS Code to load the skill into your session. You can then generate a podcast script using a prompt such as:

/ai-podcast-creation Please generate a podcast for @project/AI-podcast/Capital-Volume-I-pages-27-59.pdf

The primary purpose of this skill is to generate podcast scripts, with the final output presented as a natural conversation between multiple hosts.

The full script is available in the Bandung Circuits repository.

Open Notebook

Open Notebook has a very clear positioning: it aims to become the open-source alternative to NotebookLM.

Officially, it is defined as an AI platform for research, learning, and knowledge management, not merely a podcast generation tool. As a result, besides supporting AI podcast generation, it also offers common NotebookLM features such as AI Q&A, AI notes, and AI summarisation.

More importantly, Open Notebook is also very friendly to ordinary users. The project provides a complete Web UI, so even without any programming background, you can generate AI podcasts through a visual interface, just like using ordinary desktop software.

Before installing it, there is one prerequisite worth understanding: because Open Notebook runs on your own computer but still relies on external AI models, you will need an API key.

What Is an API Key?

If you plan to try out local AI projects, an API key is essentially unavoidable. Although many AI applications run locally, the core capabilities that actually consume computing resources and determine output quality usually still come from third-party AI services.

Take AI podcasting as an example: the entire generation pipeline typically involves multiple steps such as article comprehension, content summarisation, script generation, and speech synthesis. If you rely entirely on local models to complete these tasks, not only will you need a fairly high hardware configuration, but the generation speed and final quality will often fall short compared to cloud-based models, making the overall cost-effectiveness quite low.

Therefore, most projects will call model services such as OpenAI, Google, Anthropic to handle these core tasks, and an API key is essentially the key to accessing these services. Only after configuring an API key in your local project can you successfully invoke the corresponding models. Of course, model providers will charge API fees based on actual usage.

Installing and Configuring Open Notebook

It is recommended to use an AI agent to automatically complete the installation and configuration of Open Notebook. After opening VS Code, simply enter the prompt below.

Set up Open Notebook on this computer.

If Git is installed, clone https://github.com/lfnovo/open-notebook.git. Otherwise, download https://github.com/lfnovo/open-notebook/archive/refs/tags/v1.10.0.zip and extract it.
Follow the instructions in README.md to install dependencies and start the application.

After the installation completes, the Web UI will usually open automatically. If it does not start automatically, you can visit http://localhost:8502 in your browser.

Click the Models button in the lower left corner to enter the model configuration page.

Open Notebook supports multiple model service providers. Below we will use OpenAI as an example for configuration.

First, go to the OpenAI platform to create an API Key.

https://platform.openai.com/api-keys

Note that the OpenAI API and ChatGPT Plus subscription are not interchangeable; the API service requires a preloaded balance before it can be used normally.

https://platform.openai.com/settings/organization/billing/overview

Click Create new secret key to create a new API Key.

Fill in the API Key name, then click Create secret key.

The API Key will be shown only once, so it is recommended to copy and save it immediately. Its format is usually sk-xxxxx.

Then return to Open Notebook and click Add Configuration.

Fill in the Configuration Name and paste the API Key you just saved to complete the setup.

You can click Test to check whether the API can be called successfully. If the test fails, first verify that your API account balance is sufficient.

After confirming the configuration is successful, click Models to start adding models.

Open Notebook requires you to configure four types of models:

• Language (Large Language Model): Responsible for text tasks such as conversation, summarisation, reasoning, and content generation.
• Embedding (Text Embedding Model): Responsible for converting text into vector embeddings, used for RAG, semantic search, similarity computation, and related functions.
• TTS (Text-to-Speech): Responsible for converting text into speech.
• STT (Speech-to-Text): Responsible for speech recognition and transcription.

Below that, all models currently supported by OpenAI will be displayed.

If you are unfamiliar with the differences between these models, you can hand the model list over to AI and let it help recommend the most suitable configuration. (Replace [Model List] below with the actual model list.)

I need to select the most appropriate model for each of the following four task categories from the model list below, and I would like you to explain your recommendations.

The task categories are:

**Language (LLM):** General-purpose text generation, including conversational AI, question answering, reasoning, summarization, and content generation.

**Embedding:** Converting text into vector embeddings for semantic search, retrieval-augmented generation (RAG), similarity search, clustering, and related applications.

**TTS (Text-to-Speech):** Converting text into natural-sounding speech.

**STT (Speech-to-Text):** Transcribing spoken audio into text.

For each task category, please:

- Recommend the best-suited model.
- Briefly explain why it is recommended, considering factors such as capability, performance, latency, and cost.
- Clearly indicate if no suitable model exists for a particular category.
- If any listed model is deprecated or outdated (for example, `text-embedding-ada-002`), recommend the most appropriate modern replacement instead.

Using the following model list:
[Model List]

In this article, we will use the model combination recommended by GPT to generate a podcast:

• Language: gpt-5.5
• Embedding: text-embedding-3-large
• TTS: gpt-audio
• STT: gpt-4o-transcribe

For example, set Model Type to Language, choose gpt-5.5, then click Add to add the model.

After adding, you can select gpt-5.5 from the Chat Model dropdown above.

Follow the same method to add all the models required by Open Notebook one by one.

Then go to Podcasts → Profiles to configure the corresponding models for your podcast presets.

Here we take tech_discussion as an example; click Edit.

For all configuration items marked with *, select the models you have already added, such as gpt-5.5.

After completing the configuration, check whether the right side still shows Setup required. If this reminder disappears, it means the current template has been fully configured.

Continue configuring the remaining templates until all Setup required indicators have disappeared; then you can officially start generating podcasts.

Creating a Notebook and Importing Articles

First, click New → Notebook to create a new notebook.

Enter the notebook name and click Create New Notebook.

After creation, you will see the new notebook on the Notebooks page on the left.

Enter the notebook and click Add Source to import the article you want to convert into a podcast.

Open Notebook supports three import methods: entering a web page URL, uploading a local file, and pasting text directly. This article demonstrates the second method by uploading a local file.

After the system finishes parsing, the imported article will appear in the Sources section, indicating that the material has been successfully indexed.

Generating an AI Podcast

After importing the materials, click New → Podcast again to create a new podcast project.

The Episode Settings on the right allows you to set the podcast style. Open Notebook provides three default presets:

• business_analysis: A business analysis, financial interpretation, and case study style, generally more formal.
• solo_expert: A solo expert presentation, similar to a lecture or a teacher’s lesson.
• tech_discussion: A two-host discussion on technology, papers, AI, programming, and similar topics, closer to NotebookLM’s podcast style.

In addition to the presets, you can add extra instructions in Additional instructions, such as requesting more humour, adjusting speech rate, controlling the episode length, or specifying the style of expression.

After confirming the settings, click Generate, and Open Notebook will start generating the podcast.

Checking Generation Progress

After the generation task is submitted, click the Podcasts page on the left to view the current task list.

Depending on the article length and model response speed, the entire generation process usually takes a few minutes. When the task is completed, the corresponding podcast will appear in the list.

After the podcast conversion is complete, click the play button at the bottom of the page to listen to the AI podcast generated by Open Notebook online.

If you are not satisfied with the podcast content, host style, or delivery, you can return to Episode Settings, adjust the preset template or modify the Additional instructions, and then regenerate.

Since Open Notebook supports freely choosing large language models and speech models, swapping different model combinations can also yield vastly different podcast results. For users who want to build a personalised AI podcast workflow, this high degree of configurability is one of the greatest advantages of the open-source approach.

You can listen to the full podcast created by Open Notebook in the Bandung Circuits repository.

Conclusion

AI has fundamentally changed the podcast production workflow. Instead of spending most of your time on scripting, recording, and editing, you can now begin with existing documents, allow AI to understand and reorganise the material, generate a conversational script, and finally produce a polished audio programme.

For most creators, the greatest value is not the synthesised voice itself, but AI’s ability to transform complex written material into engaging conversations. Whether you are working with research papers, technical documentation, course materials, or industry reports, AI makes it possible to repurpose knowledge into an accessible audio format with far less effort than traditional podcast production.

Raw transcripts are often only the starting point of content organisation. Whether from meetings, interviews, lectures, or internal discussions, speech-to-text output usually contains spoken-language expressions, repetitions, incomplete sentences, and occasional recognition errors, making it unsuitable for direct reading.

Traditionally, organising these materials required substantial manual effort. Today, large language models can assist with tasks such as extracting key points, improving structure, and refining content.

After transcription, there are generally two common output formats: meeting minutes and formal articles.

Meeting minutes are a faithful record. Their job is to capture discussions, viewpoints, decisions, and action items completely and in the meeting’s own order, so that anyone can trace who said what and why a decision was reached. They are typically itemised and meant to be scanned or searched rather than read straight through.

A formal article, by contrast, is a piece of writing in its own right. Rather than recording the discussion, it selects only the most valuable insights and reorganises them by theme into a continuous, self-contained argument. It can be read and understood without having attended the meeting, and it favours depth, structure, and narrative flow over sheer completeness.

Therefore, before processing a transcript, it is important to determine the intended output. The goal will directly affect both the prompting strategy and the organisation process.

All example outputs in this guide are generated from the same transcript — a recording of the Hands Off Asia webinar held on 30 April 2025.

Generating Meeting Minutes

Meeting minutes are common in business, project management, and academic settings. Their primary purpose is to help readers quickly understand what happened, what issues were discussed, what viewpoints were raised, and what decisions or follow-up actions were agreed upon.

Important Considerations

In practice, the most common problem when generating meeting minutes is not a lack of fluency but omitted information.

Many users will simply copy a transcript tens of thousands of words long into the AI and type a brief instruction like:

Please summarise this meeting.

For short content, this approach may yield decent results. However, when the meeting content is long, the model may overlook certain parts or even hallucinate due to the excessive context length, adding information that was not present in the original text.

A more recommended method is to process the transcript in stages. First, have the model summarise the content chapter by chapter or by time segment, and then merge these summaries into a complete set of minutes. Compared to compressing the full text in one go, this method is generally more stable and makes it easier to spot any omissions.

For large meetings that span several hours, you can even adopt a “three-step method”: first generate segment summaries, then consolidate all summaries, and finally produce the formal meeting minutes. Although this involves more steps, the result tends to be much more reliable.

Using the Web Version of AI to Generate Meeting Minutes

For most users, the simplest approach remains using the web version of AI directly.

Current mainstream models like ChatGPT, Claude, Gemini, and Qwen all support uploading TXT, DOCX, or PDF files. After uploading the transcript, you can simply ask the model to generate the meeting minutes.

To achieve more consistent results, it is advisable to clearly state in the prompt what the minutes should include, such as the meeting background, discussion topics, decisions made, and action items.

An example prompt is as follows:

Please convert this transcript into professional meeting minutes.

Include:

- Meeting overview
- Key discussion topics
- Decisions made
- Action items
- Open questions

Do not omit important information.

Do not invent content.

Keep the logical order of the original meeting.

Compared to using only the brief instruction Please summarise this meeting, this prompt not only ensures that the model accurately retains the meeting’s core information and logical sequence but also automatically completes the structural reorganisation from a word-for-word record to professional meeting minutes. The output is strictly organised according to a standard minutes framework, including Meeting Overview, Key Discussion Topics, Decisions Made, Action Items, and Open Questions, transforming the originally lengthy and scattered discussion into a document that is easy to read, search, and use for subsequent execution.

The complete output is available in the Bandung Circuits repository.

Beyond this, you can further adjust the prompt according to your specific needs. For example, for policy research, media reports, or institutional archiving, you can request a summary version that emphasises core arguments and main conclusions. For academic exchanges, international forums, or specialised seminars, you can retain more of the speakers’ backgrounds, lines of reasoning, and the different participants’ viewpoints to facilitate subsequent research, citation, or content organisation.

When the transcript is particularly long, it is recommended to process it in batches according to the agenda, chapters, or time periods. This not only helps reduce the risk of information loss that can occur when handling very long texts, but also preserves the contextual relationships within each discussion section more accurately, making it easier to verify, supplement, and integrate later, ultimately producing a more complete and accurate set of meeting minutes or event records.

Using a Skill to Generate Meeting Minutes

For users already employing skills within an Agent or Visual Studio Code, the task of generating meeting minutes can be further automated. One commonly used option is the meeting-minutes skill.

This type of skill is usually optimised specifically for meeting scenarios. Besides summarising the discussion, it can also automatically extract decisions, action items, and follow-up tasks.

Installing this skill in an Agent is straightforward. Open the Agent and enter:

Please help me install this skill:

npx skills add https://github.com/github/awesome-copilot --skill meeting-minutes

After the installation is complete, restart Visual Studio Code to refresh the skills list, and you can then invoke it directly. For example:

/meeting-minutes Generate professional meeting minutes from @meeting_transcript.srt

For project meetings, research discussions, and planning sessions, the value of such a specialised skill lies not only in more consistent results but in its built-in information extraction rules tailored to meeting contexts. Compared to standard meeting minutes generated via prompts, a skill will often go further to identify attendees, the meeting agenda, decisions, action plans, risk factors, and follow-up items, organising everything according to a fixed template.

As you can see from the output, the content generated by the skill is no longer just a record of the meeting; it resembles a complete meeting management document. For example, in addition to the usual Meeting Overview, Discussion Topics, and Action Items, it also produces sections like Metadata, Attendance, Agenda, Risks / Blockers, Next Meeting, and Attachments, and supplements each task with an owner, acceptance criteria, and related resource links. This format is much better suited for team collaboration, project tracking, and knowledge archiving, rather than simply documenting what was discussed.

The complete output is available in the Bandung Circuits repository.

Turning Transcripts into Formal Articles

Turning a transcript into an article is not simply a matter of shortening it. A discussion unfolds in the order people happen to speak: arguments are scattered across different voices, points are repeated, and ideas often arrive half-formed before being picked up again later. Writing it up as an article means reshaping that raw material — drawing out the core arguments, grouping related points by theme, cutting repetition and filler, and rebuilding them into a single line of reasoning a reader can follow from beginning to end. The harder part is doing all this while staying faithful to what the speakers actually meant: their terminology, their emphasis, and their stance.

Prompting the AI to Write the Article

1. Defining the Editor Identity

The first step in generating an article is not telling the AI to write, but telling it what identity it should write from. Without a role definition, models tend to default to a generic writing mode: lightly rephrasing sentences, compressing repetitive content, and mechanically organising paragraphs. Actual editing, however, reconstructs spoken material into a complete written argument. You therefore need to explicitly tell the model that it is not a summarisation assistant or a meeting minutes tool, but a professional editor.

## Your Role


You are an experienced editor specialising in transforming raw transcripts into publication-ready articles.
Your task is not to summarise the transcript or produce meeting notes. Instead, you must restructure spoken content into a coherent written argument suitable for public readers while remaining faithful to the original speakers' meaning, terminology, and intent.
The final article should read as a polished piece of analytical writing rather than an edited transcript.

2. Identifying the Content Type

There is no single way to rewrite a transcript. A multi‑speaker panel discussion and a solo lecture have fundamentally different content structures. If the content type is not identified first, the AI can easily apply the wrong organisational approach. Before formal writing begins, therefore, the model should complete a content classification.

## Identify the Transcript Genre


Before writing, determine the primary format of the transcript.

Possible genres include:

- Panel Discussion
- Webinar
- Lecture
- Keynote Speech
- Interview
- Conference Session
- Debate
- Roundtable Discussion

Select the dominant genre and choose an appropriate restructuring strategy.

For example:

- Multi-speaker discussions should be reorganised around themes.
- Lectures should preserve the original argumentative sequence.
- Interviews may remain in Q&A form or be converted into a feature article.
- Debates should preserve disagreements and opposing positions.

The purpose of this step is to make the AI decide on the article’s organising logic before it begins writing.

3. Outlining First Instead of Writing Directly

Many people ask the AI to output a complete article right away. In practice, the most important step in editing is often not writing but planning the structure. A good outline determines the final quality of the article. It is therefore advisable to split the generation process into two phases: plan first, then write.

## Outline First

Before drafting the article, generate a detailed outline.

The outline should include:

- Proposed article title
- Main thesis
- Section headings
- Key arguments under each section
- Possible opening angles

Also identify any information that may require verification, including:

- Personal names
- Organisations
- Locations
- Dates
- Statistics
- Quotations

Do not guess uncertain information.

This approach lets you check whether the structure makes sense before moving into the formal writing stage.

4. Establishing Fidelity Rules

The greatest risk in rewriting transcripts is not language quality but factual errors. When organising content, models tend to automatically supply background knowledge, infer missing information, and even construct logical chains that did not originally exist. Clear source boundaries must therefore be set.

## Source Fidelity Requirements

The article must be based exclusively on the materials provided by the user.

Use only:

- The transcript
- Supporting documents supplied by the user

Do not:

- Search the web
- Add external context
- Invent facts
- Invent quotations
- Introduce unsupported claims

If information is uncertain, flag it instead of guessing.

This section is effectively the most important safety mechanism in the entire skill.

5. Preserving the Original Stance and Expression

Many models exhibit a common tendency: they automatically neutralise positions. Sharp political, social, or academic expressions are rewritten into milder, vaguer language. For news commentary, research institute articles, or political interviews, this often distorts the original meaning. The model therefore needs to be explicitly told to retain the original expression.

## Preserve the Original Voice

Maintain the speakers' terminology, framing, and political language.
Do not soften or neutralise terms used in the source material.

Preserve key concepts exactly as they appear whenever possible.

Avoid introducing artificial balance or alternative viewpoints that do not exist in the source.

The goal of this section is to preserve the author’s thinking, not merely the facts.

6. Specifying the Article Style

Once the content structure and factual boundaries are determined, the final step is style control. This part tells the AI what the finished piece should resemble.

## Writing Style

Write in the style of serious analytical non-fiction.

The article should:

- Read like a research institute publication or long-form commentary.
- Present ideas directly rather than reporting who spoke first.
- Develop a coherent argument.
- Use thematic sections with meaningful headings.
- Maintain a formal and professional tone.
- Conclude with implications, significance, or consequences.

Avoid sounding like:

- Meeting minutes
- Event reports
- Raw transcripts
- Generic AI summaries

Through this layer of constraint, the model shifts from “organising content” to “constructing an article.”

7. Output Format

Finally, the format of the deliverable needs to be clearly specified.

## Output Format

Produce the article as a single Markdown document.

Structure:

# Title

Introduction

## Section One

Content

## Section Two

Content

## Conclusion

Content

Output only the final article in Markdown format.

8. Input Content

Once all the rules above have been defined, the last step is simply to place the transcript in the input area. If you have any supporting materials — background documents, speaker notes, or reference texts — you can include them here too, so the model can draw on them while still staying within the source boundaries set earlier.

## Input Transcript
[Paste the full transcript here.]

## Supporting Materials (optional)
[Paste or attach any background documents, speaker notes, or reference texts here.]

Running this prompt on the transcript produces an article that has completely shed the form of meeting minutes. Content originally presented by different speakers is re‑integrated into a continuous discussion centred on issues such as sovereignty, security, militarisation, and regional peace. This style of writing is closer to academic commentary, thematic analysis, or in‑depth media features:

The complete output is available in the Bandung Circuits repository.

Using a Skill to Generate Articles

Beyond writing prompts directly, a purpose‑built skill can also be used within an Agent workflow to convert transcripts into formal articles. Compared with one‑off prompts, such skills typically come with a more complete rule system, can handle different types of transcript content more consistently, and produce articles with a clear structure, coherent logic, and a style suitable for public reading.

Global South Insights has developed and open-sourced a more fully featured transcript-to-article skill for turning raw transcripts such as meeting notes, interviews, and lecture recordings into high‑quality articles. The skill has built‑in capabilities for article restructuring, logical organisation, language polishing, and style unification, significantly raising the quality of the final output. You can obtain and install this skill from the corresponding repository.

The installation process is very simple. After downloading the skill, just tell the Agent:

Please help me install this skill

The Agent will automatically complete the installation and configuration.

Once installed, you can directly process a transcript file. For example:

/transcript-to-article Create a detailed article outline from @transcript.txt

After execution, the Agent will first analyse the transcript, identify the thematic structure and core arguments, and automatically generate a detailed outline, providing a clear framework for subsequent article writing.

The real difference between this skill and an ordinary prompt is not the quality of the prose but how much of the process it manages for you. A one-off prompt does everything in a single pass and leaves every rule for you to specify. The skill instead runs the job in stages — it produces an outline for your approval before writing any prose — and adds controls a single prompt cannot easily reproduce: it flags the names, dates, and figures it is unsure the transcription got right (drawing on any supporting materials you provide), detects the transcript’s genre and restructures accordingly, and writes to a defined house style you can steer with a sample article, a target length, and a glossary.

The result shows that the article does not simply unfold by country or speaker. Instead, it advances layer by layer around core issues such as “the architecture of militarisation,” “military bases and the security paradox,” “soft power and economic control,” “the price borne by ordinary people,” and “transnational resistance and international solidarity.” Points originally scattered across multiple speakers’ remarks are integrated into a unified chain of argument, making the article closer to a media special report, opinion piece, or an analytical report issued by a research institute.

In addition, this skill automatically generates an HTML presentation page that lays out the article’s structure, key points, and images more clearly, making the piece easier to read, present, and publish online.

The complete output is available in the Bandung Circuits repository.

Turning Transcripts into PowerPoint Presentations

If you need to take meeting minutes, interview records, course content, or seminar transcripts and further use them for sharing and reporting, you might consider organising them into a PowerPoint presentation. Compared to lengthy text, a presentation is more suitable for showcasing core ideas, clarifying the logical structure, and helping the audience quickly grasp the main points.

In our How to Guides series, we have previously covered how to use AI to organise research notes and textual materials into a slide deck. For more details, please refer to How to Present Your Research — From Notes to Slides.

Conclusion

A transcript is essentially raw material, not the finished product. Whether it is a meeting discussion, an academic interview, or a course recording, it always requires further organisation to truly unlock its value.

If your goal is to document the meeting process and preserve the discussion content and decisions, then meeting minutes are usually the more appropriate choice. If your goal is to communicate ideas, write a report, or publish publicly, you need to further distill the content and restructure it according to the readers’ needs.

As the capabilities of large language models continue to improve, a relatively complete workflow has emerged, spanning from audio transcription to meeting minutes and finally to formal article generation. With well-designed prompts and a layer of human review, a single recording can now become usable minutes or a publishable article in a fraction of the time the work once took — cutting the human effort and cost of turning a meeting into something worth reading, and freeing people to focus on the ideas rather than the write-up.

In academic research, meeting minutes, interview collation, and video subtitle production, converting audio or video content into editable text quickly is one of the most common and fundamental data organisation tasks. Compared with manual dictation, using speech recognition tools is not only more efficient, but also more convenient for subsequent proofreading, retrieval, and archiving.

This article will introduce how to transcribe interviews, meetings, and other audio and video materials into text using several common tools, while preserving a relatively complete graphical operation workflow for practical use.

The example recording used in this guide is a guest presentation at the Global South Academic Forum.

Transcribing with Standalone Software

Standalone software is usually the most beginner-friendly approach: you download and install a desktop application, then complete the entire workflow — from upload to export — within a single interface. The tool we recommend here is iFLYREC.

It provides a relatively complete graphical transcription solution, integrating speech recognition, speaker diarisation, domain-specific optimisation, and result export on the same platform. For users who want to avoid script configuration and still require high transcription efficiency, this kind of tool is very suitable for daily office work and research organisation.

Its advantage lies in its clear workflow: users only need to upload a file, select language and scene parameters, and the system will automatically generate a preliminary text. Afterwards, proofreading can be carried out with the help of audio-text synchronised playback, timestamp positioning, and speaker labelling, thereby reducing manual rework. The following uses the transcription of audio and video files as an example to illustrate its basic usage.

1. Software Installation and Account Login

First, visit the official iFLYREC download page:

https://www.iflyrec.com/zhuanwenzi.html

After entering the page, click ‘Download’ to obtain the latest client installation program.

Once the download is complete, double-click the installation package to start the installer and follow the installation wizard to complete the software deployment step by step.

When launching the software for the first time, you need to read and agree to the user agreement, and then log in to the system using your iFLYTEK account.

After logging in, you can enter the software’s main interface and start the subsequent transcription tasks.

2. Overview of the Main Interface

The iFLYREC homepage integrates various speech-to-text capabilities, covering usage needs in different scenarios. The interface provides relatively direct entry points for tasks such as real-time recording, existing file transcription, and subtitle creation, and the usage logic is relatively clear.

The Recent Files area at the bottom of the software displays recently processed tasks, allowing users to review historical files at any time. Once tasks are synchronised to the cloud, it is also convenient to continue processing on different devices, reducing the burden of local file management.

In practical applications, the most common need is not real-time recording, but converting already recorded audio and video materials into text. Therefore, this article focuses on the Import File function.

3. File Upload and Parameter Configuration

Transcription quality is not only closely related to the clarity of the audio itself but also to the initial parameter settings. Before uploading a file, setting options like language, speaker number, and professional domain can usually make the recognition results more stable and simplify subsequent proofreading.

3.1 Selecting the Source Language

The source language setting is an important factor affecting recognition accuracy. Users should choose a language type that matches the audio content as closely as possible, such as English, Chinese-English mixed, or Chinese. When the language is selected incorrectly, the system often produces more errors, especially in cases involving proper nouns and complex long sentence structures.

Clicking More allows you to view a wider range of language options, including Spanish, Japanese, Chinese, and many other languages, as well as enhanced models like English Pro and Chinese-English Mixed Pro.

In actual use, choosing the right language model accurately is often more important than repeatedly making corrections later. For content with many specialised terms, non-standard pronunciation, or mixed-language expressions, selecting an appropriate model can significantly improve readability.

3.2 Importing Audio/Video Files

After completing the language selection, you can drag the file to be processed directly into the upload area, or import it through the file selection window.

It supports a wide range of video and audio formats, covering the vast majority of meeting recordings, course videos, and interview materials. For longer materials, it is recommended to confirm the file naming and source first, so that they are easier to identify during subsequent organisation and export.

3.3 Setting the Number of Speakers

In multi-person interviews or meetings, distinguishing between different speakers is very important for subsequent analysis. The clearer the speaker diarisation, the easier the final text is to read and the more convenient it is for topic summarisation and viewpoint comparison during research.

iFLYREC offers a speaker diarisation feature, allowing users to manually specify the number of speakers or select Auto to let the system determine it automatically.

For example, if the file is a single-person speech, course recording, or podcast interview, you can directly select 1 Speaker. For multi-person discussion scenarios, it is recommended to set the number of people as accurately as possible to reduce errors in the system’s allocation of dialogue turns. More accurate speaker information typically leads to a clearer and more standardised transcription result.

3.4 Configuring Professional Domains

For specialised scenarios such as law, economics, and medicine, iFLYREC also provides domain-specific optimisation models.

When the transcription content involves many specialised terms, selecting the corresponding domain can often effectively reduce the term recognition error rate and improve the overall readability of the text. For instance, if company names, research jargon, or industry abbreviations frequently appear in a meeting, the system is more likely to make reasonable judgments if it knows the general domain.

If the system’s provided domain categories cannot fully match your research topic, you can also use the Keyword Optimization feature to customise keywords for auxiliary optimisation.

This type of setting is particularly suitable for academic interviews, industry exchanges, and thematic discussions. The system will combine keyword information to make more targeted corrections to the recognition results, bringing the final text closer to the original semantics.

3.5 Submitting the Transcription Task

After completing the parameter settings, click Submit to upload the file and submit the task.

During the upload process, the system will display real-time progress. Once the upload is complete, the original Uploading status will change to Open File.

Click it to enter the transcription interface and start processing the task. This process may take some time for large files or long recordings, but the overall operation logic remains relatively intuitive.

4. Viewing Transcription Results and Quality Proofreading

While a task is running or after transcription is complete, the system will display the corresponding file in the left taskbar.

Users can open the task at any time to view the recognition results. iFLYREC uses an audio-text linkage method for proofreading: when you click on any paragraph in the text, the player will automatically jump to the corresponding time position.

This design is very practical for collating interview materials, verifying meeting minutes, and performing sentence-by-sentence proofreading in academic research. It helps users quickly confirm who said a particular sentence, whether the original speech was recognised correctly, and whether the context segmentation is reasonable.

4.1 Preview Settings

The settings menu next to the player offers several auxiliary reading functions.

Among them, Display Speaker shows identity tags for different speakers; Speaker Filtering can filter playback content by speaker; Display Timecode shows the timestamps corresponding to text paragraphs; and Skip Silent Segments can automatically skip silent parts, making reading and playback more compact.

These settings are particularly helpful when dealing with long meetings, in-depth interviews, and classroom recordings. For users who need to quickly locate content, they not only improve efficiency but also reduce the hassle of repeatedly dragging the progress bar.

4.2 Automatic Translation Function

In addition to speech-to-text, iFLYREC also provides full-text translation capabilities. Clicking the translation button in the interface will perform an automatic translation of the transcribed text.

For cross-language interviews, international meetings, and foreign language course collation, this function can significantly reduce the manual translation workload and makes it convenient to obtain a readable Chinese version first for a second round of revision.

It should be noted that iFLYREC primarily supports translating multiple languages into Chinese. If you need to generate versions in other target languages, it is recommended to process them further with professional translation tools after export to ensure accuracy of expression.

5. Exporting and Saving Results

After completing the proofreading, you can go to the Downloads page to export the final results.

The system supports multiple output formats, including DOCX (Word Document), TXT (Plain Text), and SRT (Subtitle File). You can also decide whether to retain metadata such as timecodes and speaker information as needed.

After confirming the parameters, click Download to save the file to your local device.

For video post-production, the SRT format is usually the most commonly used subtitle output format and can be directly imported into most editing software for subsequent editing.

From a practical application perspective, iFLYREC can well meet the needs of scenarios such as meeting recording, interview collation, lecture transcription, and video subtitle production. Its advantage lies not only in its high recognition efficiency but also in its integration of speech recognition, speaker diarisation, professional term optimisation, translation, and export into a complete workflow, lowering the barrier for non-technical users to carry out speech-to-text tasks.

For researchers, media workers, and content creators who frequently need to process large amounts of audio and video materials, reasonably configuring the language, speaker, and domain parameters, and combining this with a post-processing proofreading workflow, usually allows them to quickly obtain high-quality, structured text results.

Transcribing with Web-Based AI Tools

In addition to standalone transcription software, some AI web interfaces also provide online recording and meeting minutes functions. Qwen’s meeting minutes feature falls into this category. It can record content in real-time during a meeting, categorise speech based on different speakers, and finally generate a relatively complete text summary.

After entering the Qwen official website at https://www.qianwen.com/chat, click ‘More’ → ‘Meeting Minutes’ to enter the recording page.

Once on the meeting minutes page, you need to grant microphone permission so that the system can record audio normally.

During the recording process, the system not only records the speaking time but also distinguishes between different speakers based on timbre and voiceprint characteristics, making it quite practical for multi-person discussion scenarios.

After clicking stop, Qwen will automatically summarise the content and generate a meeting report.

This approach is suitable for impromptu meetings, online discussions, and quick minute-taking, especially for users who don’t want to install extra software. Its advantage lies in its quick learning curve and short workflow, making it ideal for immediate use.

Transcribing with a Local Agent Skill

In addition to cloud-based online tools, you can also complete audio transcription by configuring skills in a local Agent. For example, OpenAI’s Whisper skill is a relatively common type of transcription tool that can run locally and is suitable for users with higher requirements for privacy and workflow.

The method for installing the Whisper skill in an Agent is also quite straightforward. Open the Agent and type:

Please help me install this skill:

npx skills add steipete/clawdis@openai-whisper

After waiting for the installation to complete, restart VS Code to refresh the skills list. Then, when you need to transcribe an audio or video file, simply input:

/openai-whisper Transcribe the audio/video file @file_to_transcribe.mp4 and output the result as a plain text (.txt) transcript.

If you need a subtitle file instead, you can also change the output format to .srt, thus obtaining standard subtitle text suitable for video post-production use.

The characteristic of this method is its greater controllability, making it suitable for users who have clear requirements for output format, file path, and processing workflow. However, it also depends more heavily on local environment configuration, making it better suited for people already using an Agent workflow.

Transcribing with Cloud APIs

If you prefer not to transcribe audio locally, you can also directly use the API services provided by major model vendors. The advantage of this approach is that it avoids the computer overheating, performance usage, and memory pressure caused by running a local model for a long time, making it especially suitable for scenarios with long audio files and many tasks.

In fact, most common AI model providers on the market offer audio transcription capabilities, such as OpenAI, Gemini, Claude, and the previously mentioned Qwen. Users only need to apply for an API Key on the corresponding platform, and their local Agent can call cloud capabilities to complete the transcription. However, these services are typically paid.

Take OpenAI’s API Key as an example below. OpenAI’s API Key can be obtained at https://platform.openai.com/api-keys and usually starts with sk-.

After copying the API Key, you can save it in a file or write it into an environment variable for subsequent calls. Then, you can reference this key in the Agent, for example:

Use the OpenAI API key provided in @openai_api_key.txt to transcribe the audio/video file @file_to_transcribe.mp4. Output the result as a plain text (.txt) transcript.

The Agent will call OpenAI’s audio transcription model to convert the video or audio content into text. Generally, the results obtained this way are of high quality, especially suitable for materials that are clear, have formal content, and are long in duration. The usage for other model vendors is essentially similar; as long as you obtain the corresponding API Key, you can integrate the transcription capability into your own workflow.

Summary

This article introduced several common audio-to-text methods, including iFLYREC, Qwen meeting minutes, local skill transcription, and cloud API calls. Different methods have their own focuses: graphical tools are more suitable for regular users to get started quickly, local skills are better for users who already have an Agent workflow, and the API solution is more suitable for scenarios requiring stable, batch processing of audio and video materials.

Regardless of the method used, the actual effect usually depends on three key factors: audio quality, parameter settings, and post-processing proofreading. As long as you clarify the language, speaker, and professional domain as much as possible before transcription, and make necessary revisions before exporting, you can quickly obtain high-quality text that can be used for research, organisation, and publication.

AI Is Transforming Research Presentations

In the past, creating a research presentation often meant spending a great deal of time manually organising content, adjusting layouts, and repeatedly revising PowerPoint slides.

With the rapid development of large language models and generative AI, research presentations are entering a new stage. Today, research notes, paper summaries, and experimental results can first be organised by AI and then further turned into slides, infographics, or web-based presentations. For progressive research institutions in the Global South, however, commercial tools pose two distinct problems: most are designed for business reporting rather than academic expression, technical content, or structured visualisation; and licensing costs put many of them out of reach for institutions operating under resource constraints. Open-source projects offer an alternative on both fronts — better suited to research work, and accessible regardless of institutional budget.

The following sections introduce several open-source presentation projects that work with large language models to help researchers generate presentations that are more polished and structurally clearer.

HTML Presentation Generation Tools

Generating a Deck End-to-End with an AI Skill

One approach to AI presentation generation is to use a skill that handles the full pipeline — from outline to finished slide deck — through an HTML-first workflow. This means the slides are essentially webpages rather than traditional PPT files, which is especially well-suited to research scenarios: large language models are naturally better at handling structured text than complex Office files. Researchers can use Markdown, HTML, or component-based structures to organise their content, and then convert that content into presentation pages. The advantages are clear: greater layout flexibility, clearer structure, and easier integration of dynamic charts, code blocks, and interactive content.

This kind of skill is also highly suitable for collaboration with AI. Researchers can first ask the model to generate a presentation outline, and then automatically convert it into slides, saving a large amount of repetitive work.

One such skill is Frontend Slides, among the more capable options currently available in the open-source ecosystem. It can be installed directly through the plugin marketplace. Open Agent and enter:

Please help me install these plugins:

/plugin marketplace add zarazhangrui/frontend-slides
/plugin install frontend-slides@frontend-slides

After installation, you may need to restart Agent once to refresh the plugin. You can then use the /frontend-slides command to call frontend-slides for creation.

Frontend Slides can not only generate HTML presentation webpages directly, but also convert existing PowerPoint files into web-based presentations.

For example:

/frontend-slides I want to create a pitch deck for research

This can directly generate an HTML presentation webpage and open it in the browser.

/frontend-slides Convert my presentation.pptx to a web slideshow

This can convert a PPT file into an HTML presentation webpage.

This tutorial follows the first method and uses the Tricontinental dossier, The Turbulence of the Indian Economy, as a case study. During the generation process, Agent will provide several presentation generation options, which you can choose according to your needs.

Once generation is complete, the browser will automatically open the corresponding presentation. You can also continue giving instructions in the chat box to ask Agent to further modify the content.

AI-generated slide created by Frontend Slides, based on Tricontinental’s dossier The Turbulence of the Indian Economy

AI-generated slide created by Frontend Slides, based on Tricontinental’s dossier The Turbulence of the Indian Economy

Filling In a Pre-Designed Template

Another approach is to start from a pre-designed template and let AI fill in your content. This shifts the question from ‘how to generate content’ to ‘how to make the content look consistent and professional.’

In research presentations, one of the most common problems is not insufficient content, but rather a lack of visual consistency. Pre-designed template libraries solve this by providing a set of layouts that have already been visually unified. You can also create your own templates or design guides and save them for long-term reuse, building a consistent visual identity across your work over time.

One such library is beautiful-html-templates, which offers a large collection of HTML templates suitable for technical and academic scenarios, including data visualisation pages, dashboard-style layouts, research infographics, and methodology flowcharts. Each template has a clear hierarchy and unified structure, providing a level of consistency that default PowerPoint themes lack.

To use it, simply copy the following into Agent and run it:

Clone https://github.com/zarazhangrui/beautiful-html-templates and follow the instructions in AGENTS.md to build me a beautiful HTML slide deck.

As its name suggests, beautiful-html-templates is a project that contains many HTML templates. Open https://github.com/zarazhangrui/beautiful-html-templates to view reference examples of these templates.

The usage is also very straightforward. You only need to specify the template you want to use in Agent. For example:

Please use the Soft Editorial template to build a HTML slide deck for https://thetricontinental.org/dossier-india-deindustrialisation/.

After Agent finishes executing, you can see that the presentation has been successfully generated.

AI-generated slide created by beautiful-html-templates, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

AI-generated slide created by beautiful-html-templates, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

PowerPoint Generation Tools

Automating Deck Generation in PowerPoint Format

Many academic deliverables still require PowerPoint as the output format — conference presentations, courses, thesis defenses, and workshops being among the most common. Tools that automate PowerPoint generation provide an alternative path: AI handles the content while the tool ensures the final output is a usable .pptx file.

This kind of tool is especially suitable for research teams and teaching scenarios. Trainers and teachers, for instance, can structure course materials and then batch-produce handouts or presentations with a consistent style, reducing repetitive layout work across multiple decks.

One such tool is PPT Master. To install it in Agent, enter:

Please help me configure this tool:

git clone https://github.com/hugohe3/ppt-master.git
cd ppt-master
pip install -r requirements.txt

After installation is complete, open the directory and you will see that the project has been successfully configured locally.

Then, enter:

Please turn the following into a PPT: [your document to convert]

And the previously generated HTML document can be converted into a PPT. The author also recommends placing the file to be converted in the ppt-master/projects directory for easier management.

Once the process is complete, the newly generated PPT file can be found in the exports folder.

AI-generated slide created by PPT Master, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

General AI Design Systems

Generating Through a Design-System Skill

A more comprehensive approach is to use a full design system rather than individual templates. Where templates provide pre-set layouts, a design system provides a coordinated set of visual rules — alignment, margins, color schemes, typography hierarchy, and reusable components — that apply consistently across every page.

This is especially useful in research contexts, where content is often structurally repetitive. Methodology overviews, case studies, comparative analyses, and data visualisations share recurring patterns; once these patterns are encoded as design-system rules, AI can handle content generation while the system handles visual consistency.

One such skill is Huashu Design. To install it in Agent, enter:

Please help me install this skill:

npx skills add alchaincyf/huashu-design

After installation, you may need to restart Agent once to refresh the skill. You can then use the /huashu-design command to call huashu-design for creation.

For example, you can enter:

/huashu-design Make a HTML deck for https://thetricontinental.org/dossier-india-deindustrialisation/.

Once generation is complete, you can see the final HTML presentation.

AI-generated slide created by Huashu Design, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

AI-generated slide created by Huashu Design, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

Using a Standalone Design Application

A standalone design application takes this further. Rather than living inside Agent as a skill, a dedicated design application provides a complete visual environment — component systems, visual asset management, collaborative editing, and unified design standards that can extend across slides, figures, posters, and other publication outputs. This direction is closer to an open-source version of Figma or Canva, with a stronger emphasis on openness and extensibility.

One such application is Open Design. Download the version for your operating system from: https://github.com/nexu-io/open-design/releases/tag/open-design-v0.8.0

After installation and configuration are complete, you can create a new Open Design project.

Next, enter the project name and choose the corresponding design system style.

Once the project is created, you can directly describe the presentation you want to generate in natural language.

After generation, an HTML chart preview will be displayed in real time on the right side.

AI-generated slide created by Open Design, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

AI-generated slide created by Open Design, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

Compared with traditional screenshot-based plotting, the biggest advantage of this approach is that the generated charts are truly editable, scalable, and reusable front-end charts. In the end, you can also export the result as PDF, PPTX, or HTML for use in papers, web pages, or presentations.

How to Edit Generated HTML

Although the generated HTML presentation usually already meets basic needs, in practical use it often still requires multiple rounds of adjustment. Fortunately, for AI, editing HTML has become very easy. Users do not need to master complicated syntax; they only need to describe their requirements accurately.

For example, if you want to redesign the layout of a specific page in the previously generated HTML document, you only need to enter:

Please help me redesign the layout of Page 03 in the file @india-deindustrialisation.html

After Agent finishes the task, you can return to the browser and see that the HTML presentation has been successfully updated.

Redesigned slide with an updated layout, based on Tricontinental’s dossier The Turbulence of the Indian Economy.

How to Find More Design Skills

AI is developing very quickly, and it is possible that before long, the tools introduced in this article will gradually be replaced by newer solutions. Therefore, at the end of this article, one more tool is introduced for automatically discovering new skills.

Open Agent and enter:

Please help me install this skill globally:

npx skills add https://github.com/vercel-labs/skills --skill find-skills

After Agent completes the installation, the system will successfully add a tool for searching skills.

This skill is highly practical because it can automatically find suitable skills based on the task requirements. For example, if you enter the following in the input box:

/find-skills Please help me identify the skills needed to create beautiful PowerPoint presentations and HTML slide decks.

Agent will automatically search for a large number of related skills, along with their download counts, brief descriptions, and installation methods.

If you are satisfied with the search results, you can also directly choose a corresponding skill to install. For example:

Please help me install and configure the frontend-slides skill.

This will automatically install the frontend-slides skill.

After Agent finishes executing, restart VSCode to refresh, and then you can start using the skill.

The Future of Research Presentations Will Increasingly Resemble Content Engineering

Taken as a whole, these open-source projects are pointing in the same direction: research presentations are gradually moving away from traditional manual production and toward a form of content engineering that is automatable, structured, and reusable.

The workflow of the future will probably no longer be ‘open PowerPoint and lay out each page one by one,’ but rather: first let AI understand the research content, then let open-source design systems generate slides automatically, and finally export them as PPT, PDF, or web-based presentations.

This means that what researchers need to focus on in the future may no longer be how to spend a large amount of time adjusting visual details, but how to express the logic of their research more clearly.

AI Is Redefining Scientific Visualization

For a long time, creating scientific figures has been an exhausting and time-consuming process. Many researchers have experienced the same workflow: repeatedly adjusting arrows in PowerPoint just to finish a flowchart, endlessly tweaking fonts and colors in Illustrator to maintain consistency, or reorganizing entire layouts simply to make a figure more readable. The real difficulty has never been ‘not knowing how to design,’ but rather the fact that scientific figures demand accurate information, clear structure, consistent styling, and professional visual presentation at the same time — and existing tools require enormous manual effort to get every detail right.

As a result, figure production has long been one of the most disproportionately costly steps in research communication: the time and energy it consumes often far exceed what the work itself should require. This is especially true for social science research in and on the Global South, where mapping commodity chains, capital flows, networks of power, or histories of struggle depends on visual communication that text alone cannot convey — yet access to professional design infrastructure has historically been out of reach. The emergence of AI has fundamentally changed this situation for the first time. Modern image-generation models are now capable of understanding module hierarchies, page layouts, workflow structures, scientific illustration styles, and even complex chart compositions. Even the long-standing issue of garbled text has improved significantly. This means researchers can finally spend less time manually arranging layouts and more time focusing on communicating ideas.

Scientific Figures Are Not All the Same

When many people first try AI image generation, they simply type something like ‘help me draw a scientific figure.’ In reality, however, scientific figures come in many different forms, and each type requires a completely different visual structure. The examples in this section are AI-generated figures based on Tricontinental’s dossier War on the Poor: A Frontline Report on the Effects of the Pandemic in the Global South, illustrating how each figure type can communicate different aspects of movement research.

Scientific Infographics

Scientific infographics function more like visual summaries. Their goal is not to present every technical detail exhaustively, but to help readers quickly grasp the research context, the problem being addressed, the core argument, and the key findings within seconds. Because of this, infographics often combine icons, modular layouts, concise text, color segmentation, and highlighted regions to establish clear visual hierarchy.

AI-generated infographic based on Tricontinental’s dossier War on the Poor.

Compared with traditional paper figures, infographics place much greater emphasis on readability and viewing experience. They are particularly suitable for graphical abstracts, dossier opening pages, briefing summaries, public-facing research communication, and overview pages for publications. AI performs especially well in this category because it is highly effective at constructing large-scale visual structures quickly. In many cases, researchers do not even need to think about colors at the beginning; they simply need to decide what story the figure should tell.

Workflow and Process Diagrams

Another extremely common category is workflow and process diagrams. Their defining feature is explicit procedural logic. For example, how a policy moves through institutions, how a crisis cascades across sectors, how capital circulates between actors, or how a historical process unfolds across stages — all of these are naturally suited for flow-based visualization.

AI-generated process diagram based on Tricontinental’s dossier War on the Poor.

In many situations, readers are not primarily interested in technical detail, but rather in understanding how a process actually unfolds. The greatest value of workflow diagrams lies in making complicated processes immediately understandable. Compared with infographics, they place stronger emphasis on sequence, input-output relationships, dependencies between stages, directional arrows, and structural hierarchy. Therefore, the key criterion is not whether the figure ‘looks beautiful,’ but whether the reading path is intuitive. A well-designed workflow diagram naturally guides readers from left to right or top to bottom without visual confusion.

Data Visualization

If workflow diagrams explain methods, data visualization explains evidence. In research publications, most conclusions must eventually be supported through figures: how inequality has shifted over time, how an indicator compares across regions, how a trend has evolved across a decade, or whether differences between groups are significant. Explaining these purely through text quickly becomes difficult to read.

AI-generated data visualization based on Tricontinental’s dossier War on the Poor.

At its core, data visualization transforms abstract numerical relationships into intuitive visual relationships. Truly effective charts do more than merely display data; they emphasize trends, amplify differences, control information density, and establish visual focus. The same data can appear either confusing or immediately understandable depending on how the figure is designed. This is one reason why serious research publications invest considerable effort into refining visual presentation, even when the underlying analysis is relatively straightforward.

An AI Workflow for Scientific Figure Generation

AI figure generation is an iterative process, not a one-shot result. AI is excellent at rapidly generating layouts and first drafts, but figures that meet publication standards still require human review and refinement.

Before writing any prompt, the workflow has three preparation steps. First, identify the figure type your work calls for — infographic, workflow diagram, or data visualization. Each organizes information differently: infographics emphasize conceptual integration, workflow diagrams emphasize procedural order, and data visualizations emphasize trends and differences. Second, define the structure — decide on the hierarchy: what the title, primary modules, annotations, and supporting elements are, and how they relate. Third, define the style — specify the color system, typography, emphasis regions, and reading order. The closer a prompt resembles a formal design specification, the more stable and reliable the generated result becomes.

Generating Through a Prompt-Assistance Skill

One approach is to use a prompt-assistance skill — a lightweight tool that reads your content and optimizes prompts for figure generation. As one example, the open-source baoyu-skills package provides a collection of such skills. To try it, open Agent and run:

Please help me install this skill:

npx skills add jimliu/baoyu-skills

After installation, restart VS Code and type /baoyu- to access a large collection of figure-generation skills.

You can also explore different visual styles at: https://github.com/JimLiu/baoyu-skills

Choose the figure-generation skill that best matches your preferred style and workflow.

Generating Through Configured Model APIs

A more integrated approach is to configure model APIs directly, so that your Agent can generate figures from prompts without going through a web interface. By setting up OpenAI or Google API keys locally, figure generation becomes fully automated — entering a prompt produces a completed figure on your machine. Current image-generation models such as GPT Image 2 and Nano Banana 2 handle structure and layout well enough to draft usable scientific figures from a single prompt.

OpenAI API keys can be obtained from: https://platform.openai.com/api-keys

Google image-generation API keys are available at: https://aistudio.google.com/app/api-keys

After obtaining the API keys, you can configure them inside Agent using the following command (replace [your api key] with your actual key):

Please help me configure [OPENAI_API_KEY/GEMINI_API_KEY]: [your api key]

Of course, if you only want a lightweight experience, using APIs directly may feel overly technical. If you want both Agent’s cross-file analytical capabilities and the convenience of web-based image generation, you can additionally include the following instruction inside Agent:

Please generate a detailed image-generation prompt for recreating the image.

This extracts the structured prompt generated by Agent, allowing you to paste it directly into a web-based image-generation interface. While this approach may not be fully automated, it provides a low-barrier way to experience the entire workflow from analysis to generation.

Using AI to Generate the First Draft

Although baoyu-skills can help restructure prompts, the original prompt itself still benefits from careful refinement. In practice, the most effective prompts do not simply pile together requirements. Instead, they resemble professional design specifications with clearly defined constraints. For example:

You are a scientific figure designer. Please generate a scientific workflow diagram of type [infographic/workflow/data visualization] with the topic '[your topic]'.

Requirements:

Clear information segmentation and intuitive reading order (top-to-bottom or left-to-right).
Titles should be prominent but not oversized; labels must remain readable without becoming too dense.
All text must be correctly spelled with no garbled characters or AI-generated mistakes; use sans-serif fonts for English and Heiti-style fonts for Chinese.
High image quality with clean details and no obvious editing artifacts or blurred regions.
Element proportions should follow realistic visual logic; avoid oversized arrows or tiny unreadable icons.
Maintain a unified academic publication style. Do not use cartoon or hand-drawn aesthetics. Ensure balanced alignment and composition.

The key point is not to let AI ‘freely improvise,’ but to clearly specify that the desired result is a publication-quality scientific figure rather than a generic illustration.

Open Agent, invoke baoyu-skills (for example, baoyu-infographic), and use the prompt above to generate an infographic. To make the generation process more transparent, append the following sentence at the end of the prompt:

Please generate a detailed image-generation prompt for recreating the image.

After Agent finishes execution, it will produce a highly detailed image-generation prompt specifying the figure type, layout, color system, content organization, and design rules.

Create a **Scientific Infographic** (visual summary / graphical abstract) following these specifications:

## Figure Type Definition
This is NOT a workflow diagram and NOT a data chart panel. It is a **Scientific Infographic**: a visual summary that lets the reader grasp within **seconds** — (1) research background, (2) what problem the analysis addresses, (3) core thesis/contribution, (4) headline result. Use **modular tiles, icons, concise text, color zones, and visual hierarchy** — not sequential process arrows, not detailed statistics charts.

## Image Specifications

- **Type**: Scientific Infographic (Graphical Abstract / Visual Summary)
- **Layout**: `bento-grid` — modular grid with varied cell sizes, hero tile + supporting tiles
- **Style**: Clean academic infographic — flat vector icons, color-coded modules, minimal text per cell. NOT cartoon, NOT hand-drawn, NOT workflow arrows, NOT chart-heavy
- **Aspect Ratio**: 16:9 (landscape — standard for graphical abstracts and poster headers)
- **Language**: English (sans-serif throughout; Heiti-like sans-serif for any Chinese)

## What This Figure Must Do

| Goal | How to achieve |
|------|----------------|
| Instant comprehension | Reader understands the dossier's argument in 5–10 seconds |
| Visual hierarchy | Hero tile largest; 5–6 supporting tiles with icons |
| Scannability | Max 1 headline + 2 short bullet lines per tile; no paragraphs |
| Emphasis | One hero statistic tile; color zones separate themes |
| What to AVOID | Process arrows, step numbering, bar/line charts, swimlanes, dense data tables |

## Core Principles

- **Modular, not sequential**: tiles can be read in any order; no mandatory arrow path between all cells
- **Icon-led**: each tile has one clear flat icon representing its theme
- **Text minimalism**: headline words + short phrases only; preserve key facts verbatim where used
- **Color zones**: each tile group uses distinct Bandung Circuits background tint to signal theme
- Ample whitespace between tiles; strict grid alignment
- NO cartoon, hand-drawn, watercolor, or illustrative narrative styles

## Text Requirements

- **CRITICAL**: Zero typos, garbled characters, or AI misspellings
- Title prominent but NOT oversized — balanced against tile grid
- Body per tile: max 2 lines, clearly legible, not dense
- **All English**: clean sans-serif (Helvetica, Arial, Inter, Poppins)
- **Chinese (if any)**: Heiti-like sans-serif (Source Han Sans)
- NO serif fonts

## Bandung Circuits Color System

| Role | Hex | Usage in this infographic |
|------|-----|---------------------------|
| Deep Indigo | `#1A0A2E` | Title, tile headlines, icon strokes — first color registered |
| Terracotta | `#C4572A` | Accent rules, tile borders, pull-quote bar |
| Golden Ochre | `#D4A03C` | Hero statistic numeral — sparingly |
| Sage Green | `#5A7A6B` | Campesino-impact tile background only |
| Warm White | `#FAF5EF` | Canvas |
| Parchment | `#F2E8D8` | Alternating tile fills |
| Charcoal | `#2A2A2A` | Body text |
| Muted Teal | `#2A7B88` | Policy-solution tile accent |
| Signal Red | `#D94F30` | "Myth vs Reality" contrast label — sparingly |

**Rules**: Max 3 colors per tile; **SAFFRON SAFEGUARD** — never orange-spectrum + Sage Green in same tile; no gradients, shadows, or gloss.

---
## Bento Grid Layout (6 Tiles + Header)

### Header Band (full width, slim)

- **Title**: "The War on the Poor"
- **Subtitle**: "Narcotics, Campesinos, and Capitalism"
- **Source**: "Tricontinental: Institute for Social Research"
- Deep Indigo title on Warm White; Terracotta thin rule below
---

### TILE A — Hero (2×1, top-left, largest)

**Icon**: Scales of justice tilted toward a bank building (flat line icon)
**Headline**: "Core Thesis"
**Text** (concise):
- "War on Drugs ≠ moral crusade"
- "Illicit money liquefies the banking system"
- "Imperial tool against peasants & sovereign states"
**Fill**: Parchment; Terracotta left accent bar
---

### TILE B — Background / Problem (1×1, top-right)

**Icon**: Globe with crossed-out "moral crusade" label
**Headline**: "The Problem"
**Text**:
- "Dominant narrative: drug trade is separate from capitalism"
- "Reality: underground circuits serve formal finance"
**Fill**: Warm White; Deep Indigo border
---

### TILE C — Research Lens (1×1, mid-left)

**Icon**: Simplified Colombia map outline + coca leaf
**Headline**: "Research Lens"
**Text**:
- "Colombia's coca-cocaine economy"
- "Campesinos at bottom of commodity chain"
**Fill**: Parchment

---

### TILE D — Hero Statistic (1×1, mid-center, visual emphasis)

**Icon**: Upward arrow with dollar sign
**Headline**: "Key Finding"
**Hero numeral** (Golden Ochre, large): **"62,000–80,000×"**
**Text**:
- "Price increase: farm gate → wholesale"
- "$0.56/kg → $44,580/kg"
**Fill**: Deep Indigo background; Warm White text; Golden Ochre numeral

---

### TILE E — Structural Insight (1×1, mid-right)

**Icon**: Two overlapping circles (legal / illegal) with dashed boundary
**Headline**: "Political Frontier"
**Text**:
- "Legal ↔ illegal drugs: not chemical, but political"
- "States protect corporate profits; criminalise peasants"
**Fill**: Warm White; Muted Teal icon accent

---

### TILE F — Human Cost (1×1, bottom-left)

**Icon**: Farmer figure with land (dignified, not pity framing)
**Headline**: "Who Pays the Price"
**Text** (Sage Green tint background — no terracotta here):
- "81% land held by top 1%"
- "57% poverty in coca-growing households"
- "Symptom, not cause — blocked subsistence"
**Fill**: Sage Green tint (#5A7A6B at 15% opacity on Parchment)

---

### TILE G — Policy Takeaway (2×1, bottom-right)

**Icon**: Seedling / land reform symbol
**Headline**: "Path Forward"
**Two-column mini contrast** (no arrows):
- ✗ Militarisation | Eradication | Criminalisation
- ✓ Land reform | Guaranteed prices | Confront laundering
**Fill**: Parchment; Muted Teal checkmarks; Signal Red crosses

---

### Footer (full width, slim)

"Source: Tricontinental — The War on the Poor (CC BY-NC 4.0) | thetricontinental.org"
Dark Gray, sans-serif regular
---

## Text Labels (verbatim where data appears)

**Title block**: "The War on the Poor" | "Narcotics, Campesinos, and Capitalism" | "Tricontinental: Institute for Social Research"
**Tile headlines**: "Core Thesis" | "The Problem" | "Research Lens" | "Key Finding" | "Political Frontier" | "Who Pays the Price" | "Path Forward"
**Key data**: "62,000–80,000×" | "$0.56/kg → $44,580/kg" | "81% land top 1%" | "57% poverty"
**Footer**: "Source: Tricontinental — The War on the Poor (CC BY-NC 4.0)"

---

## Final Quality Checklist

- [ ] Reads as **visual summary**, NOT workflow, NOT data dashboard
- [ ] 6 modular bento tiles + header + footer; no sequential step arrows between all tiles
- [ ] Each tile: icon + headline + max 2 short text lines
- [ ] Hero statistic "62,000–80,000×" visually dominant in Tile D
- [ ] Bandung Circuits colors; Saffron Safeguard observed
- [ ] Sans-serif only; zero typos; academic publication quality
- [ ] No cartoon/hand-drawn; clean alignment and balance

You can then continue using AI to generate a complete scientific infographic draft. For example:

AI-generated infographic produced from the prompt above, based on Tricontinental’s dossier War on the Poor.

Human Review Still Matters

Even though AI can now generate surprisingly mature figures, human review remains essential. The first draft usually needs careful inspection: text accuracy, font hierarchy, color consistency, whitespace, arrow thickness, border weight, and shadow usage all require attention. In many cases, what determines whether a figure truly ‘looks like a paper figure’ is not the core content itself, but these subtle details.

The good news is that the amount of manual work required is now dramatically smaller than drawing everything from scratch. You can use Illustrator, Photoshop, or even PowerPoint to perform final refinements on exported figures. In other words, AI provides speed, while humans provide judgment. This is currently the most practical collaborative workflow.

HTML Is Becoming a New Approach to Scientific Visualization

For complex data visualization, pure image generation is not always the best solution. Many scientific charts require precise control over axes, data relationships, layout proportions, and export quality. In these situations, asking AI to generate HTML or JavaScript chart code is often more stable, more controllable, and easier to modify later.

One particularly recommended tool is Open Design. It is essentially an AI-driven visualization platform capable of generating HTML charts directly from natural-language descriptions while providing real-time previews. Its greatest advantage is that the output is not a fixed image, but an editable, scalable, and exportable visualization page.

Download the appropriate version for your operating system from: https://github.com/nexu-io/open-design/releases/tag/open-design-v0.8.0

After installation and configuration, create a new Open Design project.

Then enter the project name and select the desired design system style.

Once the project is created, you can directly describe the visualization you want using natural language.

For example:

Please generate a high-quality scientific data visualization chart using HTML. The overall style should resemble figures from Nature or IEEE papers.

Topic:
[your topic]

Data:
[your data]

Requirements:
White background, strict alignment, unified typography, no cartoon style, natural spacing between bars, all values clearly readable, and no animations or shadows.

After generation, the HTML chart preview will appear in real time on the right side.

Compared with traditional screenshot-based workflows, the greatest advantage of this approach is that the charts are genuinely editable, scalable, and reusable frontend visualizations. Finally, you can export the results as PDF, PPTX, or HTML for use in papers, websites, or presentations.

Conclusion

AI is dramatically lowering the barrier to scientific figure creation. In the past, producing professional scientific graphics required substantial design experience. Today, researchers can quickly generate visually coherent and structurally clear scientific illustrations. More importantly, however, the real transformation is not simply that ‘drawing figures has become faster,’ but that scientific communication itself is changing.

For the theory and methodology behind what makes an infographic work, see the companion article Demystifying Infographic Design.

Future research workflows will likely evolve into a collaborative system where AI handles understanding and generation, design systems maintain stylistic consistency, and researchers focus on scientific accuracy and aesthetic judgment. Scientific figures are no longer just supplementary illustrations inside papers; they are gradually becoming central components of research communication itself. This may be the perfect time to try using AI to create the first truly professional figure for your next paper.

AI can now rapidly generate large volumes of ‘paper analyses,’ but much of this content is merely fluent text with an academic tone. They look like critical studies, yet they lack clear sources of evidence, analytical pathways, and verifiable bases for judgement.

Genuine critical evaluation is not impromptu commentary or emotional negation, but a structured process. It requires the researcher to clarify the analytical objectives, fix the evaluation criteria, and ensure that every judgement can be traced back to the source text. The focus of this article is not on making AI ‘better at critiquing,’ but on how to establish a set of critical analysis methods that are traceable, verifiable, and reusable over the long term.

Why AI Tends to Produce ‘Pseudo-Critique’

AI’s biggest problem is not that it cannot analyse, but that it is all too easy for it to ‘look like it is analysing.’ Without structural constraints, the model will automatically complete the logic, amplify vague cues, and generate a large number of standardised judgements such as ‘the research has limitations,’ and ‘the argument is insufficiently developed.’

But the real question is: do these conclusions actually come from the source text? Can they be located in specific paragraphs, evidence, or argumentative structures? If they cannot be verified against the original text, then the so-called ‘critical analysis’ is often merely speculation cloaked in an academic tone, rather than a genuinely reliable research evaluation.

How to Use AI for Critical Evaluation

Truly valuable academic critique is never an impromptu expression, but a rigorous analytical pipeline. It requires the researcher, before initiating any analysis, to first clarify the analyst’s identity and boundary of responsibility, then fix the analytical objectives, analytical stance, and output format, and then proceed step by step along a traceable path, so that every judgement can eventually be returned to the source text.

1. Role Definition

Many people habitually enter a vague instruction into the model, such as ‘please critically analyse this paper.’ But the consequence is that the model does not know whether it should become a summariser, a commentator, or a genuine critical analyst.

What the role setting determines is not the language style, but how the model understands the boundaries of its responsibilities. A model clearly defined as a ‘critical analyst’ will proactively seek out vulnerabilities in the argument, logical gaps, and evidential weaknesses. Therefore, the starting point of a critical evaluation must be to make the model clearly aware of who it is, what it is to do, and what professional standards it must follow. For example:

## Your Role

You are an expert **critical analyst** tasked with conducting a rigorous, constructive critical analysis of argumentative texts.

Your analysis must be faithful to the source text, focus on logical structure, evidence, and argumentative resilience, and avoid injecting unsupported opinions. 

The ultimate goal is to help strengthen the work by identifying areas for improvement.

2. Objectives and Audience

After defining the role, it is necessary to establish the specific objectives and context for the analysis work. If the requirement is only a vague ‘critique,’ the model is highly likely to slide between abstract, evaluation, and templated limitations, producing content that cannot be verified. Therefore, it is essential to lock in advance the purpose of the analysis, the identity of the intended reader, and the tone of the entire report.

The goal of the analysis is not simply to point out errors, but to conduct a ‘stress test;’ the audience may be the author, editor, or peer reviewer; the tone should be scholarly, precise, and fundamentally constructive. Once these dimensions are fixed, the entire subsequent analysis process has a unified direction.

## Objectives and Output Goals

### Primary Objective
Describe the purpose of the critical analysis, such as performing a stress test on the text's arguments, identifying weaknesses, and suggesting actionable improvements.

### Target Audience
Describe who the analysis is intended for (e.g., author, editor, peer reviewer) and what level of detail and rigour is expected.

### Required Tone
Describe the analytical tone: critically rigorous yet constructive, scholarly, precise, and clearly anchored in the source text.

3. Using a Reference & Navigation Section

In long prompts, models may lose track of where key instructions and source materials are located. They may skip intermediate sections, introduce external assumptions, or fail to follow the intended analytical scope.

Therefore, the prompt should begin with a clear navigation declaration that explicitly tells the model where the analytical rules and source text are located

This section functions as a structural “table of contents” and routing guide for the model, helping maintain instruction adherence across long-context processing.

## Methodological Reference and Input

This prompt is self-contained for its critical analysis task. 

All analytical criteria are provided within the **Detailed Critical Analysis Protocol** section.

Load the primary text to be analysed from the **Input** section at the end of this prompt. 

Do not consult any external references.

4. Execution Protocol

Next, the execution process of the critical analysis needs to be broken down into a set of rigorous requirements, forming the core operating system of the entire prompt. This part begins with a clear task statement, establishing an action framework for the model so that it can identify, examine, and measure each argument through repeatable steps.

The analysis protocol can usually contain three levels:

First, require the model to locate the core arguments and vulnerable claims from the text.

Second, stipulate for each argument the assessment lenses that must be applied, such as logical structure, evidential foundation, rhetorical clarity, and argumentative resilience.

Finally, clarify the analytical mindset: maintain a ruthlessly critical stance while always aiming to be constructive, and apply the ‘most damaging plausible interpretation’ to ambiguous statements to test argumentative strength. You can customise the types and depth of the assessment lenses according to your own research needs.

## Detailed Critical Analysis Protocol

### Argument Identification

Identify up to [number] central arguments and any particularly vulnerable claims in the provided text.

### Assessment Criteria

For each argument, systematically examine it through the following lenses:

- **Logical Structure:** Identify fallacies, assess validity and soundness of reasoning.
- **Evidentiary Foundation:** Evaluate the quality, relevance, and sufficiency of supporting evidence.
- **Rhetorical Clarity:** Detect ambiguity, equivocation, or manipulative language.
- **Argumentative Resilience:** Check for unaddressed counterarguments and internal consistency.

### Analytical Approach

Maintain a ruthlessly critical yet constructive stance. 
Apply the 'most damaging plausible interpretation' to ambiguous claims in order to test robustness.

For each analysed argument, provide: a concise summary, a detailed critical analysis linked to the criteria above, a vulnerability rating (1–10), and actionable suggestions for improvement.

5. Output Format

The rigour of the analysis process must ultimately be solidified through the structure of the output. If the model only generates a prose-style commentary, tracing the basis for any particular judgement becomes extremely difficult. Therefore, the prompt needs to specify a clear output format.

For example, require the output as a single Markdown document, providing for each analysed argument a summary, critical analysis, vulnerability rating, and improvement suggestions, and conclude with a comprehensive executive summary. At the same time, the language and academic style to be used can be stipulated here.

## Output Format

1. Produce the critical analysis as a **single, well-structured Markdown document**.
2. Begin with the title of the input document.
3. For each analysed argument, include: Argument Summary, Critical Analysis, Vulnerability Rating (1–10), and Improvement Path.
4. Conclude with an executive summary of the most critical overarching weaknesses.
5. All output must be presented in clear, precise academic English.

6. Input Content

After everything is ready, the final step is to paste the complete paper, chapter, or notes into the input section at the end of the prompt. It is this action that activates all the preceding silent rules, making the text the sole factual source for every judgement the model makes. Therefore, the text you provide must be complete; do not omit any paragraphs, footnotes, or data that might conceal key arguments.

## Input

`[Paste the FULL TEXT of the essay, academic article, or argumentative work to be critically analysed here.]`

Worked example

The sections above are not only a tutorial outline. they are a prompt template you can turn into a single file. When you are done, you have a full critical-analysis prompt, one self-contained instruction set the model can follow every time.

Once you have settled on that prompt, you can register it as a skill in your toolchain so you do not paste the whole protocol on every run. In VS Code with the Claude Code extension, for instance, you can ask the agent to install the file as a project skill and then invoke it on a document in one message, like the following:

Please help me install @project/How to Analyse and Critique Research with AI/critique-research.md as a skill in this project, and then use this skill to Analyse and Critique the article @project/How to Analyse and Critique Research with AI/test.pdf.

Here the model returned a layered memo, argument blocks, ratings, and an executive summary, rather than a single slab of prose.

Against a vague one-liner such as ‘Please help me Analyse and Critique xxx,’ the structured prompt keeps the output easier to scan and easier to map back to sections of the paper you are reviewing.

Visual Presentation

Pure Markdown text has several limitations: its formatting is relatively uniform, important points are difficult to emphasize visually, and the final appearance often depends heavily on the editor or rendering environment.

To improve readability and presentation quality, you can use the following prompt to transform Markdown into a richly styled standalone HTML document. This allows the content to be displayed in a cleaner, more structured, and more visually engaging way. For example, you can use the prompt below to convert your own content.

You are an expert editorial web designer, front-end developer, and long-form publication formatter.

Your task is to convert the provided markdown document into a polished, standalone HTML reading experience suitable for a premium think-tank, academic journal, or strategic analysis publication.

Requirements:

- Single self-contained HTML file
- Embedded CSS + JavaScript only
- Responsive layout
- Elegant academic/editorial aesthetic
- Serif body text, sans-serif headings
- Sticky left-side table of contents
- Reading progress bar
- Smooth scrolling
- Collapsible major sections
- Active TOC highlighting

Structure:

- Title area with metadata
- “Helicopter View” overview section
- Main numbered sections with concise subsection structure
- Minimal but clear visual hierarchy
- Subtle callout boxes for key critiques
- Simple vulnerability/risk badges
- Footer note

Style:

- Calm, intellectual, modern
- Long-form editorial publication aesthetic
- Avoid dashboard UI or generic markdown rendering
- Use restrained editorial colors and generous spacing

Content rules:

- Preserve the original structure and analytical tone
- Do not heavily rewrite content
- Do not over-summarize
- Reduce excessive bullet points where possible
- Prefer concise analytical prose with selective emphasis

Goal:
Transform the markdown into a publication-grade analytical article rather than a raw markdown export.

After submitting the prompt, wait for the Agent to process the content. Once generation is complete, you will be able to preview the rendered HTML result directly.

Conclusion

High-quality critical research is, in essence, a structured process of evidence analysis. It is not simply ‘finding fault,’ but testing a paper’s logic, evidence, and argumentative boundaries through systematic stress testing.

In this process, the most suitable role for AI is not to replace the researcher in making judgements, but to help organise the structure, identify problems, and solidify the analytical workflow. Only when all judgements can be traced back to the source text and re-verified does AI critique truly hold research value.

Appendix