Collective problem solving in music, art, science, and software
Jessitron · article · 2026-09-12 Reader 🖥️
Craft CommunityGenerativity (Team Contribution)Mental Models & UnderstandingSociotechnical Architecture
Great teams and great individuals are produced (not assembled from pre-existing talent) by group processes — camerata-like communities across music, art, science, and software — because such groups form a 'symmathesy': a living system of mutually learning people, tools, and (in software's unique case) the running software itself, and therefore growing individual and collective capability requires cultivating and sharing mental models within that system rather than optimizing individual output or hoarding recognition.
theoretical · mixed — Structured explicitly by the author into three parts: narrative/expository examples (Part 1), theoretical framework-building (Part 2, drawing on Bateson/Woods/Braitenberg), and speculative argument about the present moment (Part 3). The through-line is argumentative — building toward the claim that software development is best understood as 'symmathesy' — but delivered mostly through historical narrative and analogy rather than formal argument.
Structure
| Part | Role |
|---|---|
| Part 1: Examples (the Camerata, and parallels in science, art, software) | Establishes the empirical pattern by historical narrative: diverse people with a shared problem, sponsorship, shared strategy/goal, vigorous talk plus practice ('workshop'), structured criticism ('code review'), productive rivalry, and exceptional individual outcomes for members afterward. Generalizes the pattern via Ruth Katz's 'invisible college' concept in science, salons/ateliers in art (Impressionists, Van Gogh, Picasso, Ekster/Bogomazov), and two named software cameratas (the London Agile/ThoughtWorks CI-CD-DevOps group, the early Spring team). |
| Part 2: Theory (Bateson, symmathesy, mental models) | Supplies the explanatory mechanism for Part 1's pattern. Introduces Gregory Bateson/cybernetics/systems thinking, then Nora Bateson's 'symmathesy' (a learning system of learning parts) as the deeper reason groups grow people. Extends this to software specifically: the team includes the running software and its tooling, not just people (sociotechnical system). Then pivots to mental models as the operative currency of a symmathesy — introducing Woods' Law (models are incomplete, outdated, and mutually divergent), the Line of Representation (software's core observability barrier), Downhill Invention/Uphill Analysis (building is cognitively easier than understanding), and Generativity/Obliquity (the case against optimizing personal reputation over team contribution). |
| Part 3: Predictions (surrounding culture, the Symmathecist identity) | Returns to the Camerata's historical context (a culture 'pregnant' with the right conditions) to argue the present software industry is in an analogous moment, then makes the culminating identity claim: software is neither craft nor art but 'the practice of symmathesy,' and the author names herself a 'Symmathecist.' |
Key terms
- symmathesy Sociotechnical Architecture
(Borrowed from Nora Bateson, applied by the author to software) A living system composed of learning parts whose interrelationships are themselves changing as the parts learn — not just people, but also the running software, its tools, logs, and environment, all mutually shaping each other. - camerata
Generalized by the author (from the specific 16th-century Florentine Camerata) into a category: any informal, diverse, self-organizing group that forms around a shared problem, talks and practices together, and produces outsized outcomes for its members — used loosely as a common noun ('a camerata,' 'his camerata'). - generativity Generativity (Team Contribution)
The difference between a team's output with a given member present versus absent — i.e., a person's causal contribution to others' output, which can be strongly positive even when their personal/individual productivity is low (or vice versa). - Line of Representation
(From DD Woods/STELLA) The barrier between the invisible, running processes of software and what a developer can directly perceive — software can only be observed/controlled indirectly, through other software (screens, logs, tools). - Downhill Invention, Uphill Analysis
(From Valentino Braitenberg's Vehicles) The principle that constructing a system from scratch (building your own mental model as you go) is cognitively easier than reverse-engineering an understanding of an already-built system, even though building is not necessarily faster.
Propositions
- explicitGreat teams make great people, not the reverse: assembling pre-selected star developers does not by itself produce a great team, but forming a great team grows its members into great developers.conf: high
- explicitHistorically, camerata-like informal groups (the Florentine Camerata in music, 'invisible colleges' in science, salons/ateliers in art, and specific named groups in software such as the London Agile/CI-CD circle and the early Spring team) share a recognizable structural pattern: diverse participants, a shared problem, a shared (often ill-informed but legitimizing) strategy, vigorous talk combined with practice, structured mutual criticism, productive internal rivalry, and outsized individual outcomes for members afterward.conf: medium
- explicitA software development team should be defined functionally as everyone and everything required for the individual to be successful, regardless of the org chart — including the running software itself, its infrastructure, and its tooling.conf: high
- explicitA software system together with its developers forms a symmathesy: a learning system of learning parts, in which the software learns from developers (because they change it) and developers learn from the software (via its error messages, logs, and behavior).conf: highsupportsTrust Factory · p8 — Both claims independently assert that software is a symmathesy — a human-technical system whose behavior emerges from mutual learning/influence rather than one-sided control. This essay (Jessitron, 2018/2019) appears to be the original software-context source of the term via Nora Bateson; Trust Factory reuses the same framing in service of a claim about trust vs. control.
- explicitEach developer's mental model of a shared software system is necessarily incomplete, out of date, and different from every other developer's model ("Woods' Law"), and reconciling these models to communicate imposes a real cost (a 'coherence penalty').conf: high
- explicitIt is cognitively easier to build a new system from scratch (constructing your mental model as you build) than to form an accurate mental model of an already-built system of comparable complexity, even though building from scratch may not be faster.conf: high
- implicitThis asymmetry (Downhill Invention/Uphill Analysis) is the actual, usually-unstated cause of several observed software-culture phenomena: proliferation of near-duplicate frameworks, Not-Invented-Here syndrome, and preference for greenfield work over understanding legacy code.conf: medium
- explicitA single developer who holds most of a system's mental model (and keeps changing the system) can be a bottleneck that makes assigned helpers unable to contribute, regardless of the helpers' individual talent; the fix is working together on the system and deliberately investing attention in transferring the model, not assigning more people.conf: high
- explicitPersonal productivity and 'generativity' (a person's net effect on the team's output, i.e. the team's output with them minus without them) are distinct and can diverge: someone with low personal output can have high generativity by teaching and enabling others, and vice versa.conf: high
- explicitcorroboratedEvaluating and rewarding people as individuals creates an incentive to hoard useful mental models/ideas rather than share them, even though shared ideas are what make the whole team more capable.conf: highsupports ←Software Teaming: A Mob Programming, Whole-Team Approach · p22 — The book's performance-review critique (individual evaluation breeds zero-sum competition, 'no ownership of ideas') is a concrete instance of the general claim that individual evaluation incentivizes hoarding over sharing.
- explicitSoftware is categorically different from craft (competence-based, guild-like trades) and from art (a completed, individually-authored work): it is a new category — an always-unfinished, larger-than-one-person, world-affecting, continuously-changing sociotechnical system whose practice is symmathesy itself.conf: high
- explicitThe current period in the software industry is analogous to the cultural conditions that produced the Florentine Camerata — a time of experimentation and variation that lets self-organizing groups ('cameratas') form and try new practices, partly because skilled developers are scarce and the work is hard.conf: medium
- implicitBringing one's 'whole self' to work is instrumentally important because a symmathesy requires its members to be genuinely alive/present in the system in order for the system to learn and grow.conf: low
Arguments
Growing great software developers is best achieved by cultivating group/team dynamics (a 'camerata' or symmathesy), not by optimizing selection, hiring, or individual output. strength: medium
Explicit premises:
- Historical camerata-like groups across music, science, art, and software produced disproportionate numbers of exceptional individuals.
- The individuals in these groups were not pre-selected stars before joining; they became exceptional afterward.
- A symmathesy is a system of mutual learning where growth of the whole and growth of the parts are linked.
Implicit premises:
- Correlation between group membership and later individual achievement reflects a causal effect of the group on the individual (rather than e.g. survivorship bias, or a common unobserved cause such as a talent-attracting cultural moment).
- The mechanism identified in software teams (mental-model sharing, joint practice, structured criticism) is the same causal mechanism operating in 16th-century Florence and 19th-century Paris, despite very different social, economic, and technological contexts.
- 'Great' as an outcome (Wikipedia articles, founder/CEO roles, historical impact) is a valid proxy for developer/individual growth in the software case.
Inferences:
- Enumerative induction across four domains (music, science, art, software) to a general causal claim, then abduction to symmathesy as the explanatory mechanism.
Individuals should prioritize sharing mental models and growing team 'generativity' over protecting personal reputation/productivity. strength: low
Explicit premises:
- Evaluation-as-individuals creates incentives to hoard recognition and useful ideas.
- Hoarded mental models make an individual look good but shared ones make the team powerful.
- Generativity (net effect on team output) can be high even when personal productivity is low, and vice versa.
Implicit premises:
- Team-level output is the correct optimization target, not individual output or individual career advancement — a normative premise the author asserts rather than argues for.
- Organizations can and will recognize/reward generativity even though current evaluation systems are described as individual-based (an unaddressed tension: if evaluation stays individual, the incentive to hoard persists regardless of what individuals 'should' do).
Inferences:
- Practical syllogism from the productivity/generativity distinction to a normative prescription about individual behavior.
Narratives
- The Florentine Camerata: a 16th-century group of musicians, artists, poets, and philosophers, sponsored by Bardi and Corsi, who set out to reform polyphonic music by 'reviving' (actually reinventing) ancient Greek word-setting, talked and practiced together, held formal structured criticism sessions, had productive internal rivalries (Bardi vs. Corsi, Caccini vs. Peri), and collectively invented the music-drama/opera — with an outsized share of members going on to notable individual careers.
→ The primary supporting narrative for the entire thesis; functions as the extended analogy from which every subsequent claim (invisible colleges, salons, software cameratas, symmathesy) is generalized. Explicitly mapped onto software practices: 'they did code review.' - Von Neumann bringing Hungarian high-school classmates to Los Alamos for the Manhattan Project.
→ Supports the 'invisible college' proposition — that credited individual genius (Nobel-style single-name recognition) obscures a supporting network that enabled it. - Van Gogh living among fellow artists/dealers/critics in Montmartre; Gauguin influencing Picasso; Aleksandra Ekster carrying Cubism to Kiev and mentoring Alexander Bogomazov.
→ Extends the camerata pattern into visual art, and personalizes it (the author owns a Bogomazov print), supporting the claim that the pattern is domain-general, not software- or even discipline-specific. - The London Agile/ThoughtWorks group (2003-2006) that produced Continuous Integration, Continuous Delivery, DevOps, BDD, and microservices thinking; and the early Spring Framework team, both of which later produced multiple founders/CEOs.
→ Grounds the abstract camerata pattern in the reader's own professional world (software), providing the direct evidential bridge to the software-specific theoretical claims in Part 2. - The 'purple developer' diagram: a developer with a full mental model of a system, versus 'blue' and 'green' developers assigned to help who cannot, because they lack the model and the purple developer keeps changing the system faster than they can catch up.
→ Illustrates and makes concrete the abstract claims about mental-model incompleteness/divergence (Woods' Law) and the practical failure mode of assuming headcount substitutes for shared understanding. - The historical shift from craft guilds (competence-guaranteeing, talent-agnostic) to Renaissance 'Art' (individual talent recognized, cross-disciplinary academies replacing single-trade guilds).
→ Serves as the analogy underpinning the essay's culminating claim that software is undergoing (or has undergone) an equivalent categorical shift — from craft to something new ('symmathesy') — positioning the present as 'the next thing after the Renaissance.'
Questions addressed
- ✅ Why do certain teams produce disproportionately many individually exceptional people?
Because such teams function as a symmathesy — a mutually-learning system — in which growing the shared system necessarily grows its individual members; the causal arrow runs group-to-individual rather than individual-to-group. - ✅ Why are accurate mental models of software systems so hard to form and share?
Two named structural reasons: the Line of Representation (software's running state is not directly observable) and Downhill Invention/Uphill Analysis (building your own model is cognitively cheaper than reconstructing someone else's). - ✅ Why do common software behaviors like framework proliferation, Not-Invented-Here syndrome, and greenfield preference persist despite being widely criticized as wasteful?
They are rational responses to the cognitive asymmetry of Downhill Invention vs. Uphill Analysis, not simply irrationality, ego, or laziness. - ⭕ How should individual contribution be evaluated on a team, given that personal output and team-enabling behavior can diverge or even oppose each other?
The author proposes the concept of 'generativity' as what should be recognized and credited, but does not resolve HOW an organization would practically measure or reward it, especially given her own observation that individual evaluation creates hoarding incentives. - ⭕ Is the camerata pattern actually a reliable predictor of exceptional outcomes, or is it visible only in retrospect via survivorship bias (i.e., are there many similarly-structured groups from history that produced nothing notable)?
Gaps
- incompleteThe essay never addresses survivorship bias: it draws its entire inductive base from groups that are famous precisely because they succeeded (Camerata, Impressionists, Manhattan Project physicists, the London Agile group, early Spring). It offers no comparison to the base rate of similarly-diverse, similarly-talkative, similarly-practicing groups that produced nothing notable, so the claim 'camerata structure causes exceptional outcomes' is not actually distinguished from 'exceptional outcomes retroactively get called a camerata.'
Read next: Literature on survivorship bias in studies of success/innovation (e.g., critiques of 'best practices from famous companies' research); sociology-of-science work on the base rate of research collaborations/invisible colleges relative to how many are later celebrated. - incompleteThe central practical prescription (individuals should optimize 'generativity,' sharing mental models, over personal productivity/reputation) is not reconciled with the essay's own diagnosis that individual-based evaluation systems create hoarding incentives. No mechanism, structural change, or evaluation redesign is proposed to align incentives with the recommended behavior — it is left as a personal-values appeal.
Read next: Organizational-design literature on team-based vs. individual incentive/compensation systems, and on measuring 'enabling' or multiplier contributions (e.g., staff-engineer archetypes, 'multiplier' vs. 'diminisher' leadership frameworks) that attempt to operationalize exactly this gap. - uninformedThe essay treats the Camerata's ignorance of actual ancient Greek musical practice as a harmless, even useful, legitimizing fiction ('like citing computer science papers from the 70s'), without engaging with the epistemic risk that such founding myths pose when a group's shared 'ground truth' is simply wrong — a risk directly relevant to software teams whose shared mental models can be confidently wrong in the same way.
Read next: Work on how groups sustain false shared beliefs / groupthink despite (or because of) shared practice and mutual reinforcement — e.g., organizational research on 'espoused theory vs. theory-in-use' (Argyris), or on collective illusions. - incompleteThe claim that software is categorically neither craft nor art but something wholly new ('the next thing after the Renaissance') is asserted through rhetorical contrast rather than argued: the essay does not consider that software might instead be a hybrid or a special case of pre-existing categories (e.g., infrastructure/engineering systems like power grids or air-traffic-control systems, which are also continuously-running, larger-than-one-person, world-affecting sociotechnical systems) rather than something genuinely unprecedented.
Read next: Comparative work on other continuously-operated, never-finished sociotechnical infrastructures (aviation, power grids, financial-market systems) and resilience-engineering literature (Woods, Hollnagel) that already treats these as symmathesy-like joint cognitive systems, which would question the 'software is the first' framing.