Writing technical articles is an art - this is simply wrong. While writing technical articles may feel like an art to some, it’s primarily a methodological process that anyone can learn.

The methodical process of crafting effective technical articles has been refined over centuries—from the classical rhetoric of Aristotle and Cicero to modern research on creativity, cognitive load, and working memory. You’ve likely seen the results of this process in action, even if the authors weren’t consciously following a specific framework.

Here a quick selection and analysis I did based on my latest bookmarked HackerNews articles:

  1. David Crawshaw’s article “How I Program with LLMs”: While it doesn’t strictly adhere to an algorithmic framework, this piece embodies key aspects of classical rhetoric. It features a clear structure, signposting with the statement, “There are three ways I use LLMs in my day-to-day programming.” Additionally, the article concludes with a clear call to action by introducing his project, sketch.dev, encouraging readers to explore it further.
  2. The post “State of S3 - Your Laptop is no Laptop anymore - a personal Rant": This article follows a classical rhetorical structure by providing a clear introduction, a main body with three arguments and rebuttals, and a closing that emphasizes the need for action—urging readers to “state your refusal” regarding the current state of laptop standby functionality.

These examples demonstrate that even without following a specific algorithmic framework, effective technical writing often naturally aligns with classical rhetorical principles and the same methodological process.

This methodological process can be formalized further in a “algorithmic” framework for writing effective technical articles:

  1. Introduction:
    • Hook: Capture attention with a compelling opening.
    • Ethos: Establish credibility and context.
    • Subject: Define the topic or problem being addressed.
    • Message: Present the central insight or analogy.
    • Background: Provide context or explain why this is relevant now.
    • Signpost: Outline the article structure (e.g., ArgA, ArgB, ArgC).
    • Light Pathos: Subtle emotional appeal tied to the reader’s goals.
    • Transition: Smooth segue into the main content.
  2. Argument A, B, and C:
    • Claim: State the main point/step/key concept.
    • Qualifiers: Acknowledge any limitations to your claim.
    • Grounds: Provide evidence or examples supporting the claim.
    • Rebuttals: Address potential counterarguments.
    • (Optional) Warrants and Backing: State and back-up underlying assumptions if needed.
    • Transition: Bridge to the next argument or section.
  3. Conclusion:
    • HookFinish: Return to the hook for closure.
    • Summary: Summarize the main points of the article.
    • Message: Reinforce your central insight or analogy.
    • Strong Pathos: Final emotional appeal to motivate action.
    • CTA: End with a clear, actionable step for the reader.

Think of writing an article as applying an algorithm: define your inputs, process them through a sequence of logical steps, and arrive at the output. Each step corresponds to a clear function or subroutine.

To prove that it actually works, I’ll apply it to this article, so you can watch each step unfold in real time.

I frequently publish technical articles in the IT/OT domain, some of which have been featured on HackerNews as well. Many colleagues and peers have asked how I manage to produce well-researched technical content alongside my responsibilities as a CTO. Part of my role involves sharing knowledge through writing, and over time, I’ve developed an efficient method that combines classical rhetorical techniques with the use of LLMs (o1 <3). This approach allows me to quickly craft articles while maintaining quality and clarity, avoiding common pitfalls that can arise with AI-generated content.

I wrote this article to formalize my process—not only to streamline my own writing but also to assist others who have valuable insights yet struggle to share them effectively within our industry. By outlining this framework, I hope to help others produce impactful technical articles more efficiently.

Fig. 1: Somewhat relevant xkcd #1081

Fig. 1: Somewhat relevant xkcd #1081

In the tradition of classical rhetoric, I’ll present three core steps (or also called “arguments”):

  1. Lay the Foundation, which shows how to find the three main steps/key concepts/arguments based on your subject, message and call-to-action, using creativity and filter techniques
  2. Build Rhetoric, which uses classic concepts like ethos, pathos, logos to shape your arguments into a compelling form; and
  3. Refine for Readability, which uses techniques inspired by modern research to ensure that your work can be understood by the reader and sparks joy.

Mastering this approach doesn’t just make writing easier-it can advance your career, earn you recognition from your peers, and position you as a thought leader in your field.

Ready to see how it all comes together? Let’s start by setting up our essential inputs-so you can experience firsthand how formulaic thinking simplifies the entire writing process.

A. Lay the Foundation (Your Original Ideas)

// LayTheFoundation defines core input parameters
func LayTheFoundation() (
    subject string,
    message string,
    cta string,
    argA, argB, argC Argument,
)

To run an algorithm, you generally need to identify all the input parameters before calling the function.

However, it’s possible to start with default or partially defined parameters and refine them iteratively (see also chapter 3). Ultimately, for the algorithm to produce accurate and reliable results, all inputs should be clearly defined by the final iteration.

Similarly, when writing technical articles, defining your key ‘inputs’—your subject, call-to-action, and message—is essential. After establishing these inputs, you’ll generate a range of potential angles (your arguments), then converge on the top three that best support your message. Finally, you’ll back them up with evidence and address alternative methods or counterarguments.

A.1. Define Your Inputs (Subject, CTA, Message)

Before you can start writing the article, you need to establish three key inputs that will drive your entire article.

A.1.1. Subject

subject = "algorithmic framework for writing effective technical articles"

This is the core issue or problem you want to address. It should be clear, focused, and relevant to your audience.

LLM Advice
Must be done manually, do not use LLM here!

A.1.2. Call-to-Action (CTA)

cta = "Apply this algorithmic framework to your next technical article and experience how it transforms your writing"

This is the specific action you want your readers to take next.

As a CTO, most of my articles subtly nudge readers toward using our product. Drawing from my experience, I’ll focus this subsection on crafting effective CTAs that align with promotional goals while maintaining value for the reader.

However, the CTA isn’t limited to promotional goals—it works just as well for purely informational pieces. You could guide readers to “check out my bio,” “watch my latest conference speech,” or “try out this open-source project.”

Avoid generic marketing prompts like “Contact us now!”—they often clutter websites and turn off technical readers who want more substance first.

Reading an article rarely convinces introverted technical readers to make a phone call. It’s more effective to offer a smaller, relevant next step-like a link to deeper content, a demo, or a GitHub repo. Over time, they may trust you enough to seek further interaction.

LLM Advice
Must be done manually, do not use LLM here!

A.1.3. Message

message = "Writing is applying an algorithm."

This is the central insight or theme of your article in a short sentence, ideally six words or less and free of clichés. Include a subtle rhetorical device if it fits naturally.

By defining these inputs, you clarify your input parameters for the next sub-routine to gather “key concepts”, “steps” or how they are called in classic rhetoric: “arguments”

LLM Advice
Must be done manually, do not use LLM here!

A.2. Define your Arguments

From the previous section, we have defined the inputs. Now we can derive the arguments from them.

A.2.1. An argument is a claim supported by reasons

Let’s first talk about the elephant in the room:

“I’m writing a step-by-step guide or informational piece; I don’t need arguments.”.

It’s easy to think that arguments are only necessary for debates or persuasive essays. However, at its core, an argument is simply a claim supported by reasons 1. This means that effective communication—regardless of format—involves presenting claims and supporting them with reasons.

Here’s the key takeaway: Regardless of what you call them—arguments, key concepts, steps, or insights—the underlying principle is the same. Effective communication relies on structuring information in a way that supports the overall message and helps the audience grasp the content.

In technical writing, these “arguments” manifest in various forms depending on the type of content you’re creating:

  1. Tutorials: Each step is a claim about what the reader should do, supported by reasons explaining why this step is necessary.
  2. White Papers: Each supporting point is a claim about industry trends or product benefits, substantiated by research and analysis.
  3. Explanatory Articles: Key concepts or clarifications are claims about how something works, supported by detailed explanations.
  4. Case Studies: Phases of a project or results-driven highlights are claims about actions taken and their outcomes, backed by real-world evidence.

A.2.2. The Toulmin System for Analyzing and Constructing Arguments

In modern rhetoric, the Toulmin System2 is a valuable tool for analyzing and constructing arguments. It helps break down arguments into their essential components, making them clearer and more persuasive.

In this chapter, we will focus on identifying the major points for each argument:

  • Claim: The main point or position that you’re trying to get the audience to accept.
  • Grounds: The evidence—facts, data, or reasoning—that supports the claim.

Some claims might have underlying assumptions, so we will also define them:

  • Warrant: The underlying assumption or principle that connects the grounds to the claim, explaining why the grounds support the claim.
  • Backing: Additional justification or evidence to support the warrant, making it more acceptable to the audience.

Additionally, acknowledging possible counterarguments strengthens your position:

  • Rebuttal: Recognition of potential counterarguments or exceptions that might challenge the claim.

A.2.3. Gather Arguments (Divergent Thinking)

// GatherArguments collects raw brainstorming output (unfiltered ideas).
func GatherArguments(subject, message string) (rawArgs []string)
If you already have a list of all of your potential key concepts/steps/arguments, feel free to skip this and go directly to Cluster and Filter (Convergent Thinking)

Good and original articles usually present novel and applicable, and therefore also creative ideas.

In modern scientific literature 3, creativity is often divided into divergent and convergent thinking—first, you expand your pool of ideas (divergent), then you narrow them down (convergent) .

This is sometimes referred to as the “double diamond model” (Fig. 2) 4, which visualizes the process as two connected diamonds, each representing a divergent (expansion) and convergent (narrowing) phase.

Fig. 2: The Double Diamond is a visual representation of the design and innovation process. It’s a simple way to describe the steps taken in any design and innovation project, irrespective of methods and tools used.

Fig. 2: The Double Diamond is a visual representation of the design and innovation process. It’s a simple way to describe the steps taken in any design and innovation project, irrespective of methods and tools used.

This is exactly what we will do in the next steps.

A.2.3.1. Choose a Creativity Technique

First, use a creativity technique to brainstorm at least six different arguments, steps, or key concepts for your article. The specific method you choose will depend on your style, but brainstorming is often the easiest and most effective option. Some other accepted techniques include mind mapping, 6 thinking hats, or morphological boxes5.

And yes, creativity can be systematized - techniques such as brainstorming or brainwriting are widely recognized and used in practice, although empirical evidence of their effectiveness is limited and often qualitative in nature 5 6

A.2.3.2. Gather a Broad Range of Ideas

rawArgs = {
  "Define inputs first",
  "Explore structure and prose (introductions, transitions, signposts)",
  "Emphasize original insights (why new facts matter)",
  "Discuss LLM usage (can AI help with clarity?)",
  "Refine readability (bullet points, visuals, concise language)",
  "Address counterarguments (alternative methods, pitfalls)",
  "Cats with laser eyes"
}

At this stage, anything goes. Your goal is to diverge - to generate as many ideas as possible without worrying about relevance, overlap, or feasibility.

Fig. 3: Going crazy here is important for creativity

Fig. 3: Going crazy here is important for creativity

Some ideas may seem redundant, irrelevant, or even silly. That’s okay - it’s part of the process. The goal is quantity, not quality. Refinement comes later in the convergent thinking phase.

LLM Advice
Can be supported by an LLM, but the main points must come from you as the author.

A.3. Cluster and Filter (Convergent Thinking)

// ClusterAndFilterArguments applies clustering and the "MECE" principle.
func ClusterAndFilterArguments(
    subject string, 
    message string,
    rawArgs []string,
) (argA Argument, argB Argument, argC Argument)

By brainstorming freely, you’ve created a pool of ideas from which to draw. Now let’s converge those ideas: first, we group them, check if they are MECE, narrow them down to three arguments, and add evidence.

clusters = {
  "Inputs and foundational concepts.",
  "Structuring content for clarity",
  "Ensuring readability and engagement",
  "LLM usage",
  "Weird stuff",
}

Look for patterns or themes that can be combined. For example, if you’ve brainstormed steps for a tutorial, some might logically fit into broader categories. If you’ve generated supporting points for a white paper, identify themes or recurring concepts.

If “cats with laser eyes” doesn’t support your message, drop it or mention it briefly as a playful anecdote.

LLM Advice
Can be supported by an LLM, but main clusters may come from you as the author.

A.3.2. Apply the MECE Principle

func AreArgumentsMECE(argA Argument, argB Argument, argC Argument) (bool, bool, bool)

To further refine your clusters, use the MECE (Mutually Exclusive, Collectively Exhaustive) approach. This approach gained popularity in consulting firms, especially McKinsey, to ensure no overlap and no gaps7.

1. Mutually exclusive Make sure each item covers a unique idea. Avoid overlap, which can confuse the reader or make your argument repetitive.

Example:

  • “How to use LLMs” and “Making it pretty” overlap because LLMs can help refine prose. These should either be merged or excluded to avoid redundancy.

2. Collectively exhaustive Together, your points should cover all critical aspects of your article’s message. Avoid leaving any part of your topic, CTA, or message unsupported.

For example:

  • If the message is “Writing is like coding,” then arguments about readability and structure are critical. However, a stand-alone discussion of LLMs might be tangential unless it directly supports the main topic.

Tip: As you refine, keep asking yourself: Does each argument stand on its own? Together, do they fully support my message?

LLM Advice
Can be supported by an LLM with the prompt “please analyze whether the given arguments are MECE and provide the most critical review while still remaining objective”

A.3.3. Narrow Down to Three Claims

argA.claim = "Lay the Foundation (Your Original Ideas)"
argB.claim = "Build Rhetoric (Your Logical Structure)"
argC.claim = "Refine for Readability (Why It Sparks Joy)"

Once your clusters are refined, select the three most important arguments. If you are writing a tutorial and have more than three steps, obviously don’t remove steps. Instead, continue clustering related ideas until you have three overarching categories of steps.

Why focus on three main points? Readers' working memory has its limits—typically, people can hold about 3-4 items in mind at once (see also Chapter 3). By limiting your main arguments to three, you make it easier for readers to follow and remember your key points without overwhelming them.

LLM Advice
Needs to be done manually

A.4. Add Grounds and Rebuttal

// AddGroundsAndRebuttalForArgument enhances each argument
// with supporting evidence (grounds) and addresses potential
// counterarguments (rebuttal) to strengthen your overall case.
func AddGroundsAndRebuttalForArgument(arg Argument) (revisedArg Argument)
argA.grounds = [
    "An argument is a claim supported by reasons [Ramage et al., 1997].",
    "Creativity research distinguishes between divergent and convergent thinking (Zhang et al., 2020).",
    "Over 100 creativity techniques exist, but few are backed by robust empirical studies (Leopoldino et al., 2016)."
]

argA.rebuttals = [
    "Why not just skip divergent thinking and start writing? (Counterargument: leads to tunnel vision)",
    "Why exactly three points? That feels artificial (Counterargument: limited working memory and cognitive load studies)"
]

Now that you’ve identified your three main points, back them up with data, anecdotes, or examples. If you’re writing a tutorial, explain why each step is important and how it contributes to the overall goal. Address potential alternatives or common misconceptions to reinforce the validity of your approach.

Types of Evidence to Support Your Arguments 1:

  • Personal Experience: Share relevant experiences that illustrate your point.
  • Observation or Field Research: Include findings from firsthand observations or research.
  • Interviews, Questionnaires, Surveys: Incorporate data gathered from others.
  • Library or Internet Research: Reference credible sources that support your claim.
  • Testimony: Use expert opinions or eyewitness accounts.
  • Statistical Data: Present statistics to provide quantifiable support.
  • Hypothetical Examples: Offer scenarios that help illustrate your argument.
  • Reasoned Sequence of Ideas: Use logical reasoning to connect concepts.

By enriching your arguments with evidence and addressing counterarguments, you make your content more convincing and comprehensive.

LLM Advice
Can be enriched by an LLM by providing background knowledge, e.g. “I remember that this framework has a lot of similarities to classical rhetoric. Can you compare my framework to classical rhetoric and provide background information? Check for hallucinations and link sources!”

A.5. (Optional) Add Warrants, Backing and Rebuttal

argA.warrants = [
	"Defining key inputs is essential in writing, just as identifying variables is crucial in solving mathematical problems."
]

argA.backings = [
    "The Toulmin System formalizes arguments, enhancing clarity and persuasiveness.",
]

In many cases, successful arguments require just these components: a claim, grounds, and a warrant (sometimes implicit). If there’s a chance the audience might question the underlying assumption (warrant), make it explicit and provide backing.

By stating warrants and providing backing, you reinforce the connection between your grounds and your claim, making your argument more robust.

A.6. Conclusion

By defining your inputs, brainstorming various angles, and selecting the top three MECE (Mutually Exclusive, Collectively Exhaustive)-compliant arguments—each backed by evidence—you establish a solid foundation for a compelling article. Applying the Toulmin System ensures that your arguments are clear, logical, and persuasive.

However, even the best ideas won’t resonate if they’re hidden in a tangle of bullet points. Let’s explore how to create a logical flow that keeps your audience engaged. In Argument B, we’ll identify additional inputs and begin integrating them into a cohesive narrative.

B. Build Rhetoric (Your Logical Structure)

// BuildRhetoric constructs rhetorical elements
func BuildRhetoric(
    subject, message, cta string, 
    argA, argB, argC Argument,  
) (
    hook string, 
    hookFinish string,
    ethos string,
    background string,
    signpost string, 
    lightPathos string,
    strongPathos string,
    transitionIntroMain string,
    summary string,
    updatedArgA, 
    updatedArgB, 
    updatedArgC Argument,
)

Building rhetoric to “glue together” your arguments, established in the previous chapter, is typically a repeatable and well-defined process, much like a function in your code.

While there may be exceptions when crafting a rhetorical masterpiece involving intricate metaphors or unique stylistic devices, for most technical articles, following a structured approach ensures clarity and effectiveness.

For centuries, rhetoricians like Aristotle and Cicero have emphasized the importance of structure in persuasive communication. Cicero’s famous works 8 break down any speech into distinct parts, from the initial hook (exordium) to the closing appeal (peroratio):

  1. Exordium: Captures attention and establishes credibility (ethos).
  2. Narratio: Outlines the topic and provides necessary background.
  3. Divisio: Highlights the structure of the argument and prepares the audience for what’s to come.
  4. Confirmatio: Presents the main arguments with supporting evidence (logos).
  5. Refutatio: Preemptively addresses counterarguments or opposing views.
  6. Peroratio: Closes with a memorable emotional appeal (pathos) and reiterates the main point.

Why use rhetoric at all? Simple: A well-structured article ensures that readers can follow your logic without getting lost. Elements like background (narratio) and signposting (divisio) help readers break down complex topics into manageable parts, making the content easier to understand. Summaries and well-crafted transitions between arguments further aid readers in memorizing your key points.

In this chapter, we’ll map our inputs and outputs from Argument A (Subject, Message, and CTA) onto a rhetorical framework inspired by the classical masters. We’ll see how a strong hook grabs attention early, how concise transitions keep readers on track, and how a final “hook finish” underscores your main point.

B.1. Hook (Exordium)

hook = "Writing articles is an art - this is plain wrong. ..."

Purpose: Immediately capture the reader’s attention (exordium). In classical rhetoric, the exorcism is crucial - Aristotle argued that you must first secure the audience’s goodwill and attention.

Position: Introduction

Three rules:

  • Keep it short and intriguing.
  • Avoid cliched “clickbait” lines.
  • Optionally include a personal anecdote, but don’t dwell on biography.
LLM Advice
You need to come up with your own hook, and then let the LLM just fix the grammar and spelling for you. Otherwise, the LLM tends to be clickbait.

B.2. Hook Finish

hookFinish = "See? By applying a clear, repeatable process, we’ve shown that ..."

Purpose: To repeat the hook at the end of the article, giving a sense of closure. In classical rhetoric, returning to your opening statement helps the audience feel that the piece has come full circle.

Position: Outro

LLM Advice
Can be generated by the LLM based on your hook.

B.3. Ethos

ethos = "The methodical process of crafting effective technical articles has been refined over centuries ..."

Purpose: To establish trust or credibility. In classical rhetoric, founded by Aristotle 9, ethos demonstrates why the audience should care about your perspective.

Position: Introduction

LLM Advice
Must be done by hand, but the LLM can help you correct grammar and spelling.

B.4. Background (Narratio)

background = "To prove it actually works, I’m applying it to this piece so you can watch each step unfold in real-time.

I frequently publish technical articles in the IT/OT domain, some of which have been featured on HackerNews as well. Many colleagues and peers have asked how I manage to produce well-researched technical content alongside my responsibilities as a CTO.
"

Purpose: To provide context for why you wrote this article. In classical rhetoric, the narratio sets the stage by explaining the situation or problem.

Position: Introduction

LLM Advice
Must be done by hand, but the LLM can help you correct grammar and spelling.

B.5. Signpost (Divisio)

signpost = "Following the tradition of classical rhetoric, I’ll present three core arguments: ..."

Purpose: Introduce your main points or steps, and let the reader know how the article is organized. If you do not use it, you run the risk of losing the reader during the article (especially if the article is longer). See also chapter 3 for scientific background.

Position: Introduction

Advice: “There are three key arguments…” or “We’ll break this problem down into three steps…”

LLM Advice
Can be fully generated by the LLM

B.6. Strong Pathos

strongPathos = "Don’t let your innovative ideas get lost in subpar articles. ..."

Purpose: Pathos in classical rhetoric persuades by appealing to the audience’s emotions. It’s a final push to motivate action. Should be related to your CTA.

Position: Outro

LLM Advice
Needs manual input, LLM can correct grammar and spelling

B.7. Light Pathos

lightPathos = "Mastering this approach doesn’t just simplify writing—..."

Purpose: To create a subtle emotional pull at the beginning of your article.

Position: Introduction

LLM Advice
Can be derived from strong pathos

B.8. Transition from the intro into main

transitionIntroMain = "Ready to see how it all comes together? ..."

Purpose: A bridging sentence from the introduction to the body. Helps readers understand when the introduction ends and the main arguments begin.

Position: Introduction

LLM Advice
Can be completely generated by LLM

B.9. Updated Arguments with Intro, Summary and Transition to the next argument

argA.qualifier = "This can also happen with “unclear defined” input parameters or default parameters ..."

argA.context = "Similarly, when writing technical articles, defining your key 'inputs'—your subject, ..."

argA.summary = "By defining your inputs, brainstorming various angles, and selecting the top three MECE-compliant arguments—..."

argA.transitionA_B = "However, even the best ideas won't resonate if they're hidden in a tangle of bullet points. ..."

In the Toulmin Model arguments are broken down into key components. Previously we identified the claim, grounds, rebuttal, warrants, and backing. Now we add the remaining elements:

  1. Context: Provide background to prepare the reader. If the argument is long, add small signposts that prepare the reader for the evidence he will then see.
  2. Qualifier (Scope and Limitations): Acknowledge any limitations to your claim. Use qualifiers to indicate the strength of your claim (e.g., “typically,” “often,” “in most cases”).
  3. Summary: Recap the key points made in the argument, reinforcing how the evidence supports the claim.
  4. Transition: Connect to the next argument or concluding section, easing the reader’s cognitive load and preparing them for what’s to come.

Context, summary and transitions aren’t just filler! They help the reader “offload” details from working memory. In Chapter 3, we’ll explore exactly why this is important, by going into the science of cognitive load and memory limits. We’ll show how these introductions, summaries, and transitions keep readers focused on the key points.

LLM Advice
Can be completely generated by LLM

B.10. Conclusion

By applying classical rhetoric, you turn ideas into a compelling narrative. A strong hook captures attention, ethos builds credibility, and background provides context. Signposts, summaries, and transitions ensure logical flow, while strategic pathos engages readers emotionally.

Next, we’ll pull these threads together into a polished, persuasive piece.

C. Refine for Readability (Why It Sparks Joy)

// FinalizeArticle combines all elements
func FinalizeArticle(
    // ... inputs from previous functions ...
) (
    finalizedArticle string,
)

This final step focuses on readability, bridging the gap between your carefully crafted logic and your readers' actual ability to process it.

Readability is always important, though the degree of simplification may vary depending on your audience’s expertise. Even with highly specialized or technical readers, clear and accessible language enhances understanding and engagement.

Because by now you have all your rhetorical “ingredients”-the big ideas (arguments A & B & C) and the rhetorical framework. But even a perfect structure will fail if it’s buried in 5,000-word paragraphs or stuffed with excessive jargon.

Fig. 4: Somewhat relevant xkcd #2864

Fig. 4: Somewhat relevant xkcd #2864

C.1. Apply Algorithm

// ApplyAlgorithm takes in everything from LayTheFoundation() and BuildRhetoric() 
// (like subject, message, CTA, rhetorical elements) and merges them into a coherent draft.
func ApplyAlgorithm(
    ... // everything from LayTheFoundation() and BuildRhetoric() 
) (
    articleDraft string,
)

Now we have all input parameters, so we can execute our algorithm to get a good article draft. You can find the full algorithm/template at the beginning of this article.

C.2. Increase Readability

// IncreaseReadability applies style and formatting
func IncreaseReadability(
    articleDraft string,
) (
    finalizedArticle string,
)

Readability is the ease with which a reader can digest your text. This depends on understanding that humans have limited working memory and cannot juggle a dozen new concepts at once 10.

Recent reviews on working memory 11 and cognitive load 12 13 highlight that 3-4 items is the upper limit that most people can hold in working memory before overload sets in.

Introducing complex or specialized terms without adequate explanation increases extraneous cognitive load—the unnecessary mental effort imposed by the way information is presented, not by the content itself.

LLM Advice
An LLM can help identify complex terms in your writing and suggest definitions or simpler alternatives to improve clarity and reduce cognitive load.

C.2.1. Cognitive Load and Working Memory

Working memory is the system responsible for temporarily holding and processing information in our minds. It has limited capacity and if too much information is presented at once, it can overwhelm this capacity, leading to confusion and decreased comprehension.

Cognitive load theory explains how different types of load affect our ability to process information 13:

  • Intrinsic Load: The inherent complexity of the material itself (e.g., intricate concepts or detailed procedures).
  • Extraneous Load: The additional burden imposed by the way information is presented (e.g., poor organization, unnecessary jargon).
  • Germane Load: The mental effort required to process, construct, and automate schemas (e.g., applying knowledge to problem-solving).

Technical articles usually already have a high intrinsic load, so we need to make sure that we keep the extraneous load as low as possible and reduce the intrinsic load to make room for the germane load.

Optimize Through Content Organization

Congratulations! Because you’ve already made your arguments MECE in the first chapter of this article, you’ve already reduced the reader’s extra mental effort, because now he doesn’t have to decide where each piece of information belongs.

And by using the signpost, they don’t have to keep track of what comes next.

Finally, you also incorporated rehearsal to promote germane load (i.e., beneficial active processing) and prevents accidental overload by giving the reader a mental break. When dealing with complex topics, you need rehearsal to make the knowledge stick. Rehearsal can be as simple as a brief summary at the end of one argument or a bridging transition at the beginning of the next. These elements help the reader “empty” their working memory of the old information before loading the next chunk. The summaries and transitions between arguments do just that.

You can further reinforce your structure with clear headings, but we’ll see more about formatting in the next chapter.

Eliminate Unnecessary Complex Words and Explain Terms Step-by-Step

Even a perfectly chunked, three-argument structure can fail if the text is littered with obscure jargon that forces the reader to go back and forth (extraneous load). A good rule is to introduce technical terms only when absolutely necessary, and to define them succinctly on the spot.

Don’t get me wrong: it’s perfectly fine to use jargon! Just make sure it is necessary. And be really sure that your audience knows it, not all “standard” jargon is universal across sub-domains.

For example: If you use the formal term “conditional statement” in a Go tutorial, clarify with a quick note that it refers to “if-statements”—a term that’s often misunderstood by juniors (I’ve lost count of how many times I’ve heard “if-loops”).

This principle applies even if you are writing for a technical audience. Not everyone has the same background. Format them so that advanced readers can quickly skip them.

Example: MQTT explanation

Bad:

MQTT is an OASIS standard messaging protocol for the Internet of Things (IoT). It is designed as an extremely lightweight publish/subscribe messaging transport that is ideal for connecting remote devices with a small code footprint and minimal network bandwidth.14

Potential confusion: “What is OASIS?” “What does publish/subscribe mean?” “Why should I use it?”

Better:

MQTT (Message Queue Telemetry Transport) is a protocol designed for communication between devices. It uses a publish/subscribe architecture, where devices (publishers) send messages to a central message broker. Other devices (subscribers) that are interested can then receive the messages from the broker.

Compared to other architectures, publish/subscribe allows for near real-time data exchange and decoupling between devices, which makes it easy to add or remove devices without disrupting the network.

Among publish/subscribe protocols, MQTT is simple and lightweight. This allows millions of low-power, memory-constrained devices—common in Internet of Things (IoT) applications to communicate with each other.

Here, the definitions arrive exactly when needed, not hidden in footnotes or introduced 20 paragraphs later. This reduces extraneous load.

C.2.2. Formatting

Implementing good formatting goes beyond aesthetics-it reduces extraneous cognitive load by helping readers see where they are, what’s important, and what’s next. Below are best practices drawn from common technical writing standards and research-tested web guidelines 15.

1. Sentence & Paragraph Length

Aim for a range of sentence lengths. Short, punchy lines maintain momentum, while a few medium or longer sentences provide depth. Too many uniform or run-on sentences can make text either choppy or difficult to follow.

Keep paragraphs concise. Readers often skim or read on mobile devices, so large blocks of text can be overwhelming. Try to keep paragraphs to a few sentences at a time-this is often called a “scannable style.

Use active voice instead of passive voice.

Eliminate meaningless words and phrases. Some come from generative AI or are due to “fluff”. Phrases like “in order to” or “basically” can often be cut because they add no real meaning.

2. Structural Cues and Headings

In earlier chapters, you identified your main arguments (MECE and no more than three). Each argument deserves a clear heading (H2) and subheadings (H3) for supporting facts.

3. Use visual elements such as graphics, pictures, and images to break up large blocks of text.

But avoid images that are “busy,” cluttered, and contain too many extraneous details, and don’t place text around or on top of them to the point of distraction. Label images appropriately so that the reader is not left guessing what a diagram or code snippet represents.

4. Use bullets, numbers, quotes, code blocks, and white space to break up large blocks of text.

Break up large blocks of text by using:

  1. Bullets or
  2. Numbers to structure your content clearly and concisely.

You can use such quotes to highlight quotes from external sources or important statements and further break up the text.

fmt.Println("Since we're (usually) programmers, include code blocks as examples to make concepts concrete.")

Use enough white space between web page elements.

Guideline: On a smartphone, include a visual or structural element (e.g., bullet point, image, subheading) about every screen length of text. This ensures readability without overwhelming the reader.

5. Avoid using italic or underlined text; use bold instead.

Avoid using italics in the body of the text. Use bold to emphasize key words and concepts. Avoid underlining large blocks of text as this makes it difficult to read.

C.3. Final Tips for Iteration and Review

Creating an exceptional article often requires multiple iterations. As you refine your work, you might discover that certain arguments need strengthening, some details are missing, or that your prose could be more engaging. Embrace this part of the process—iterative refinement is key to producing high-quality content.

Iterate Using the Framework

Don’t hesitate to loop back through the algorithmic framework you’ve established. Revisiting each step can help you identify areas that need adjustment, ensuring that your article remains coherent and compelling. Whether it’s refining your arguments, enhancing your rhetoric, or improving readability, the framework serves as a reliable guide.

Gain a Fresh Perspective

Sometimes, viewing your article from a different vantage point can reveal insights you might have missed. Here are some techniques to consider:

  • Reverse Reading: Read your article paragraph by paragraph from the end to the beginning. This approach can help you spot inconsistencies, redundancies, or logical gaps that aren’t as apparent when reading in the usual order.

  • Pause and Reflect: Take a short break from your work. Stepping away, even briefly, can provide clarity when you return to your article.

  • Seek Critical Feedback: Use tools like AI language models to obtain an objective review of your work. Ask for critical feedback to identify weaknesses or areas for improvement that you might have overlooked.

LLM Advice
Leverage AI tools to enhance your revision process. Prompt an AI assistant with: “Please provide a critical review of my article, focusing on areas that need improvement while remaining objective.” AI can offer fresh insights, highlight inconsistencies, and suggest enhancements you may not have considered.
Eliminate Redundancies

Be on the lookout for repetitive information, especially between the endings of sections and the beginnings of the next. For instance, if the conclusion of one argument mirrors the introduction of the following argument, consider consolidating them. This not only tightens your writing but also maintains the reader’s engagement by avoiding unnecessary repetition.

Polish Your Language

Refining your language enhances readability and professionalism.

  • Grammar and Style Checks: Utilize tools like DeepL Write or other grammar assistants to catch errors, improve sentence structure, and ensure clarity.

  • Vocabulary Consistency: Aim to use advanced terms consistently throughout your article. Introducing complex terminology only once can confuse readers. If you use specialized terms, ensure they are defined and revisited as necessary to reinforce understanding.

  • Read Aloud: Reading your article aloud can help you catch awkward phrasings, run-on sentences, or abrupt transitions that you might not notice when reading silently.

Final Considerations

Remember that perfection is a process. Each revision brings you closer to a polished and impactful article. By methodically applying your framework, seeking fresh perspectives, and diligently refining your language, you enhance both the quality of your writing and its resonance with your audience.

C.4. Conclusion

Readability sparks joy because it closes the loop on everything you’ve built in Chapter 1 (Content & Logic) and Chapter 2 (Rhetorical Structure). By completing your draft and improving readability, you ensure that even the most technical topics will be accessible, engaging, and memorable to your audience.

By following these steps, your article will not only contain valuable information, but also present it in a way that truly resonates with readers.

Conclusion

See? By applying a clear, repeatable process, we’ve shown that writing technical articles isn’t just ‘art’—it can be learned by anyone willing to follow the steps.

This article embodies the very framework it presents: a clear introduction, three structured arguments, and a concise conclusion with a compelling call to action. By following this repeatable process, you can transform your technical expertise into articles that effectively inform and engage your audience.

Think of writing an article as applying an algorithm: define your inputs, process them through a sequence of logical steps, and arrive at the output. Each step corresponds to a clear function or subroutine.

Don’t let your valuable insights get lost in poorly structured content. Share them in a way that captivates and informs your readers. Apply this algorithmic framework to your next article and experience the difference it makes.

Now it’s your turn to use this process to create technical articles that resonate with your audience! Simply start by copying this article and your latest article or your current article draft into the same LLM prompt and ask it to apply the framework.


  1. Ramage, John D., John C. Bean and June Johnson. “Writing Arguments : A Rhetoric with Readings.” (1997). ↩︎

  2. Toulmin, Stephen E.. “The Uses of Argument, Updated Edition.” (2008). ↩︎

  3. Zhang, Weitao, Zsuzsika Sjoerds and Bernhard Hommel. “Metacontrol of human creativity: The neurocognitive mechanisms of convergent and divergent thinking.” NeuroImage (2020): 116572 . ↩︎

  4. British Design Council. “The Double Diamond: A universally accepted depiction of the design process.” (2005). Accessible via: https://www.designcouncil.org.uk/our-resources/the-double-diamond/ ↩︎

  5. Leopoldino, Kleidson Daniel Medeiros, Mario Orestes Aguirre González, Paula de Oliveira Ferreira, José Raeudo Pereira and Marcus Eduardo Costa Souto. “Creativity techniques: a systematic literature review.” (2016). ↩︎

  6. Saha, Shishir Kumar, M. Selvi, Gural Buyukcan and Mirza Mohymen. “A systematic review on creativity techniques for requirements engineering.” 2012 International Conference on Informatics, Electronics & Vision (ICIEV) (2012): 34-39. ↩︎

  7. Wikipedia. https://en.wikipedia.org/wiki/MECE_principle ↩︎

  8. Cicero, De Inventione↩︎

  9. Aristotle, Rhetoric↩︎

  10. https://en.wikipedia.org/wiki/Readability ↩︎

  11. Buschman, T. J.. “Balancing Flexibility and Interference in Working Memory.” Annual review of vision science (2021): n. pag. ↩︎

  12. Leppink, Jimmie, Fred Paas, Cees P. M. van der Vleuten, Tamara van Gog and Jeroen J. G. van Merriënboer. “Development of an instrument for measuring different types of cognitive load.” Behavior Research Methods 45 (2013): 1058 - 1072. ↩︎

  13. Klepsch, Melina and Tina Seufert. “Understanding instructional design effects by differentiated measurement of intrinsic, extraneous, and germane cognitive load.” Instructional Science 48 (2020): 45-77. ↩︎

  14. https://www.mqtt.org ↩︎

  15. Miniukovich, Aliaksei, Michele Scaltritti, Simone Sulpizio and Antonella De Angeli. “Guideline-Based Evaluation of Web Readability.” Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems (2019): n. pag. ↩︎