Writing vs. Thinking
Masoud Bahrami · article · 2026-09-21 Reader 🖥️
Writing is not merely a record of a thought fully formed beforehand but one of the mechanisms by which thinking itself happens — a claim the author grounds in how articulation forces precision, how revision continues (rather than merely polishes) an argument, and how the same dynamic explains why naming and language do real design work in software, not just communication work.
theoretical, illustrated practically · reflective essay (personal blog), built from a real LinkedIn exchange and worked examples — Structured as a chain of short, titled sections rather than a formal argument; moves from a personal anecdote to a general claim about cognition, then to a worked practical exercise, then to a domain-specific application (software naming/DDD), and back to the opening exchange. No citations beyond one passing reference to Vygotsky; evidence is introspective and anecdotal throughout, not empirical.
Structure
| Part | Role |
|---|---|
| Opening exchange with Mathias Verraes | narrative hook / thesis trigger |
| "The thought we think we already have" (personal example) | supporting narrative |
| "Writing is not a printer for thoughts" (+ Vygotsky citation) | core supporting reasoning |
| "Try explaining something you think you understand" (fill-in-the-blank exercise) | practical demonstration / reader-replicable evidence |
| "Speaking is not writing" | contrast / boundary-drawing |
| "The page remembers for you" (A/B/C contradiction example) | mechanism claim |
| "Revision is not just cleaning" | reframing / extension of the thesis to editing |
| "And sometimes you discover that you were wrong" (component-size example) | narrative payoff |
| "This is also why language matters in software" (ProcessRequest example) | domain transfer / central parallel |
| "Code is another form of writing" | generalizing move |
| "Have all the ideas already been said?" (return to Mathias) | resolution of the opening tension |
| "Writing as a conversation with your future self" | closing reframing of revision |
| "The last edit" (closing) | conclusion |
Key terms
- writing Writing as Thinking
Not the transcription of an already-complete thought (a "printer for thoughts") but an active, participatory process that forces precision, exposes gaps, and sometimes reverses the writer's starting position. Deliberately widened to include code artifacts — class names, method names, tests, APIs, domain models, architecture documents, schemas — anything that gives implicit knowledge an inspectable, arguable external form. - revision
Not mere cleaning or polishing of an already-correct draft, but a continuation of the same discovery process as the first draft; an edit is often implicitly a question ("is this actually what I mean?") rather than only a correction ("make it better"), and can produce a different argument, not just a cleaner one. - language / naming (in software)
Extends the writing-as-thinking claim into Domain-Driven Design's territory: a name like ProcessRequest() lets the author avoid deciding what "process" actually means; forcing a precise name (ValidateEligibility, CalculatePremium, IssuePolicy, NotifyCustomer) exposes distinctions in the domain that were already hiding inside the undifferentiated behavior. Language is claimed to help discover the design, not merely communicate an already-settled one.
Propositions
- explicitWriting is not merely a record of a thought that already existed complete before the writing began; it is one of the ways thinking itself happens.conf: highsupportsWhat we lose when AI writes for us · p2 — Near-identical thesis independently argued: both claim writing is thinking, not a separable report of thought formed beforehand.
- explicitEven when a writer already knows a subject well, the act of writing can trigger new ideas or discoveries that were not present before writing began.conf: high
- explicitA thought, before it is written, is typically less precise than the sentence eventually used to express it; writing forces determinate choices (is it A or B, is this always true or only sometimes, is this a cause or a correlation) that a pre-verbal thought does not require.conf: high
- explicitThe relationship between thought and word is not a one-way encoding but a two-directional process; thought is completed in the word rather than simply copied into it (citing Vygotsky).conf: medium
- explicitAttempting to explain, in writing, something you believe you understand well often reveals that the understanding is less complete than it felt before writing.conf: highsupportsBrain Food: Answers Without Effort · p8 — Same mechanism (writing an idea out forces you to find and resolve loose ends) illustrated with a different narrative — Bezos's memo practice vs. this essay's fill-in-the-blank exercise.
- explicitWriting differs cognitively from speaking because a writer lacks the shared situational context and real-time feedback a speaker has, and so must make relationships between ideas explicit that speech can leave implicit.conf: high
- explicitBecause writing persists (unlike speech, which disappears), it becomes a stable external object the writer can return to later and disagree with, in a way an unwritten thought cannot be revisited.conf: high
- explicitWriting offloads relationships among multiple ideas (e.g., A causes B, B depends on C, C is the same as A) from working memory onto an inspectable external surface, making contradictions visible without requiring active mental recall.conf: high
- explicitRevision is not only cleaning or improving an already-correct draft — an edit is often implicitly a question ("is this actually what I mean?") rather than only a correction ("make it better"), and can change the argument itself, not just its wording.conf: high
- explicitWriting an article can correct an author's original argument, not merely communicate it — starting from one claim and, through the act of writing and encountering counterexamples, arriving at a substantively different claim.conf: high
- explicitIn software, precise names do not merely make code more readable — replacing a vague name (ProcessRequest) with precise ones (ValidateEligibility, CalculatePremium, IssuePolicy, NotifyCustomer) exposes distinctions in the domain that were already hiding inside undifferentiated behavior; language helps discover the design, not only communicate an already-settled one.conf: highextendsThe Best Prompting Advice Came From a Writing Teacher · p10 — Zinsser/Svenson extend writing-as-thinking into prompting ("writing-to-think rather than writing-to-output"); this doc extends the same thesis into software naming/design — a parallel domain application of the same underlying claim.extendsSoftware Design in the Agentic Age: Placing Your Bets · p11 — Both argue naming/ubiquitous language does real cognitive and design work, not just readability/comfort; this doc supplies a concrete before/after example (ProcessRequest -> ValidateEligibility/CalculatePremium/IssuePolicy/NotifyCustomer) for the general claim.
- explicitCode artifacts — class names, method names, tests, APIs, domain models, architecture documents, database schemas — are themselves forms of writing, in that each gives something implicit in someone's head an inspectable, arguable external form.conf: highextendsWhat we lose when AI writes for us · p3 — Franco argues the Self is constituted by writing from a blank page; this doc extends the same self-formation claim to code artifacts by arguing code-writing is not a substitute for prose-writing but an instance of the same activity.
- implicitThe value of engaging (in writing) with an idea that has "already been said" lies not in the novelty of its content but in whether the writer can see it differently; genuine personal understanding of an idea — even an old, familiar one — is typically only reached by struggling to put it into words oneself, not by reading about it or agreeing with it.conf: medium
- explicitWriting is a learned skill, distinct from speech (which is acquired naturally in growing up), that requires deliberately learning to structure an argument, make distinctions, and avoid becoming too attached to an earlier draft, because the thought captured in it is still developing.conf: high
Arguments
Writing is a way of thinking, not merely a report of thought that happened beforehand. strength: medium
Explicit premises:
- A thought, before it is written, is typically vague and imprecise relative to the sentence eventually used to express it.
- Writing forces determinate linguistic choices (word choice, causal vs. correlational framing, categorical distinctions) that a pre-verbal thought does not require.
- When such forced choices change a sentence's meaning, the change can propagate and alter the surrounding argument or example (shown in the software-architecture narrative and the component-size narrative).
Implicit premises:
- The precision/determinacy achieved through linguistic choice-forcing constitutes, or is inseparable from, genuine thought — i.e., "thinking" just is (partly) the making of such determinate distinctions, not a separate prior mental event that writing merely reports afterward.
- Unaided human cognition cannot reliably hold and compare several complex relationships among ideas (the A/B/C case) without an external representation, so writing's stabilizing, inspectable surface is doing real cognitive work rather than merely recording work already done in the head.
Inferences:
- Inductive generalization from a small number of personal introspective anecdotes (one software-architecture example, one component-size example, one fill-in-the-blank exercise) to a general claim about how thinking works.
- Analogical support drawn from a name-dropped external authority (Vygotsky) whose theory is not otherwise argued for or contested, just cited as consonant with the author's introspection.
In software design, naming and language don't just communicate a design — they help discover it, extending the general writing-as-thinking claim into the domain of code. strength: medium
Explicit premises:
- A vague method name like ProcessRequest() lets the author avoid deciding what "process" actually means.
- Replacing it with precise names (ValidateEligibility, CalculatePremium, IssuePolicy, NotifyCustomer) requires making decisions about what the behavior actually is, which exposes distinctions that were previously hidden inside undifferentiated behavior.
Implicit premises:
- The distinctions exposed by precise naming were already latently present in the domain/behavior — naming is a discovery process, not an arbitrary act of labeling — which is the software-specific instance of the essay's general claim that writing doesn't just express thought, it forces and completes it.
- Writing code (naming classes, methods, tests, schemas) engages the same cognitive process as writing prose, not merely a superficially similar but functionally distinct discipline (e.g., one partly constrained by compiler/type-system rules rather than the open-ended "what do I actually mean" question prose poses).
Inferences:
- Analogical extension from the prose case (argued at length across most of the essay) to the code case (argued in two short sections at the end).
Narratives
- The author's LinkedIn exchange with Mathias Verraes about the endless-editing stage of a long essay, where Mathias reveals the discoveries he associates with "final edits" were really discoveries made while writing.
→ Opens and closes the essay; supplies the seed observation for the whole thesis and the occasion the essay returns to at the end. - A first-person account of trying to write a paragraph explaining a software-architecture idea, where each sentence-level word choice destabilizes the next paragraph, eventually revealing the original example didn't support the argument.
→ Concrete, blow-by-blow demonstration that writing changes the thought as it happens, not just its expression. - A reader-replicable exercise: pick something you believe you understand well (e.g., why your team's architecture is hard to change) and complete a series of forced-continuation prompts about it.
→ Turns the abstract claim into a personal, testable demonstration that felt understanding often outruns articulable understanding. - A worked example of three claims about A, B, and C (A causes B, B depends on C, C is the same thing as A) that, once written down, visibly contradict each other.
→ Illustrates the externalized-working-memory mechanism — the page makes contradictions visible without requiring active recall. - A narrative of starting an article with the claim "Good architecture means having small components," then recalling counterexample systems where small components made things worse, and revising to a claim about the cost of changing relationships between components rather than component size itself.
→ Shows revision reversing/correcting the author's starting argument rather than merely polishing it. - The ProcessRequest() → ValidateEligibility()/CalculatePremium()/IssuePolicy()/NotifyCustomer() renaming example.
→ Concrete software-domain illustration of language exposing hidden distinctions in a domain, bridging the essay's prose-focused argument to Domain-Driven Design. - A personified account of successive drafts as different versions of the author in dialogue — the first draft says "this is what I think," the second asks "really?", the third raises a counterexample, the fourth says "that isn't actually what you meant."
→ Reframes revision as an ongoing conversation across time rather than a terminal cleanup step, closing the essay's argument about what revision is.
Questions addressed
- ✅ Is writing merely a record of thought that happens after thinking, or is it part of the thinking process itself?
The author argues writing is one of the ways we think, not just a downstream report of thought, grounded in the observation that writing changes the thought as it's produced. - ✅ Why does putting an idea into words (rather than just holding it in mind) change or clarify it?
Partially resolved by two intertwined claims: language forces determinate choices a pre-verbal thought doesn't require (the Vygotsky-flavored argument), and writing offloads relationships among ideas onto an external, inspectable surface, relieving the need to hold them all in working memory at once (the A/B/C example). The essay never distinguishes which of these is doing the actual causal work, or whether they're the same mechanism described twice. - ✅ What is revision actually doing, if not just cleaning up prose?
Revision is framed as a continuation of the same discovery process as the first draft — an edit is often a question ("is this what I mean?") that can produce a different argument, not just a tidier one. - ✅ Why does naming and language matter so much in software design, beyond code readability?
Naming forces the same kind of precision-forcing choices as writing prose does, which is how it helps discover — not only communicate — a design; explicitly extends Domain-Driven Design's "ubiquitous language" idea. - ✅ Have all worthwhile ideas already been said, making it pointless to write about them again?
The author revises his own opening claim under Mathias's pushback, concluding the useful question isn't novelty of content but whether the writer can see something differently — and that genuinely understanding even an old idea usually requires the personal effort of writing it out. - ⭕ Does everyone need to write in order to think well, or can some people reason clearly and reach real understanding without externalizing thought this way?
Gaps
- incompleteNo engagement with counterexamples: people who reason clearly and reach genuine understanding without writing (highly verbal thinkers, oral-tradition reasoning, live discussion, REPL/interactive exploration), or via other externalization media (sketching, diagramming, talking through an idea with someone else). The essay treats writing as uniquely load-bearing for thought without considering whether other externalization forms achieve the same clarifying effect — or, more strongly, whether some people think well with no externalization at all.
Read next: Read against extract-franco-what-we-lose-when-ai-writes#g4, which raises exactly this question (drawing, coding, deliberating aloud, longhand journaling, careful prompting as possible substitutes for writing) and points to embodied/extended-cognition literature (Andy Clark) as a place to look for an answer. - incompleteThe causal mechanism by which externalization aids cognition is asserted via the A/B/C example and a passing Vygotsky citation, but never grounded or disambiguated: is it working-memory-limit relief (a cognitive-load account), distributed/extended cognition (the page becoming part of the cognitive system), or simply the discipline of grammar forcing precision? The essay gestures at all three without saying which is doing the causal work, or whether they are the same mechanism described three different ways.
Read next: Would benefit from engagement with extended-mind theory (Clark & Chalmers) or working-memory research, rather than relying on introspective anecdote and one name-dropped citation. - incompleteThe claim that code is "another form of writing" — and therefore does the same thinking work as prose — is asserted by declaration rather than independently argued. The essay never explains why writing code should activate the same cognitive process as writing prose, rather than being a related but distinct discipline (e.g., naming partly constrained by compiler/type-system rules and existing conventions, not by the same open-ended "what do I actually mean" question prose poses).
Read next: Compare with extract-software-design-agentic-age-placing-bets#p11 on why human-legible naming and Ubiquitous Language matter functionally — that argument grounds the claim in shared-language requirements across code/docs/conversation rather than in a cognitive-process equivalence with prose writing. - uninformedNo engagement with the existing literature this essay's claims overlap heavily with — writing-to-learn research in composition studies, extended-mind theory (Clark & Chalmers), or Zettelkasten-style "note-taking as thinking" work (e.g., Ahrens' How to Take Smart Notes) — beyond one passing reference to Vygotsky.
Closes gaps elsewhere
- What we lose when AI writes for us · g4 — That gap asks why writing is privileged as the unique site of effortful self-formation when other articulation practices — drawing, coding, deliberating aloud, prompting — might substitute for it. This document's "Code is another form of writing" section directly addresses the coding alternative, but by reframing rather than resolving it: it argues coding doesn't substitute for writing because it already is writing in the relevant cognitive sense (naming, tests, schemas all give implicit knowledge an inspectable, arguable form). This only partially closes the gap — it says nothing about the other listed alternatives (drawing, deliberating aloud, careful prompting), so the broader question of whether non-code, non-prose practices can substitute remains open.