# 03-on-the-citizen-developer-20250417

Great. I’ll draft a speculative essay in the style of The New Yorker exploring the concept of the "citizen developer" within the liberal arts tradition, drawing connections to the classical figure of the "citizen orator." It will argue that AI—especially tools enabling intuitive, aesthetic-driven or "vibe" coding—extends rhetorical agency by democratizing access to software creation. I’ll bring in cultural and historical context, and show how liberal arts values like persuasion, storytelling, and civic engagement are finding a new digital expression.

I'll get started and let you know when it's ready to review.

# Speaking in Code: The New Citizen Orators of the Digital Age

([File:Cicero Denounces Catiline in the Roman Senate by Cesare Maccari.png - Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Cicero_Denounces_Catiline_in_the_Roman_Senate_by_Cesare_Maccari.png)) *A 19th-century painting by Cesare Maccari depicts a Roman statesman addressing the Senate, exemplifying the classical ideal of the citizen-orator.* In the year 63 BC, Marcus Tullius Cicero stood before the Roman Senate and delivered a withering denunciation of a conspiracy threatening the republic. Cicero’s oration, rich in eloquence and civic conviction, helped sway the course of Roman history. To the ancients, this was the epitome of civic engagement: a **citizen orator** using mastery of language and persuasion to defend the public good. Cicero argued that a great orator needed not only eloquence but moral character and broad knowledge on civic matters ([Rhetoric - Wikipedia](https://en.wikipedia.org/wiki/Rhetoric#Rome#:~:text=Cicero%20argued%20that%20art%20required,sapientia%29%20and)). In *De Oratore*, he insisted that effective rhetoric arose from the union of wisdom (*sapientia*) and eloquence (*eloquentia*), so that the speaker’s skill was guided by integrity and learning ([Rhetoric - Wikipedia](https://en.wikipedia.org/wiki/Rhetoric#Rome#:~:text=eloquence%20%28eloquentia%29.,advanced%20the%20tradition%20by%20systematizing)). Quintilian, another Roman rhetorician, later summed up the ideal succinctly: the perfect orator is “first a good man, and after that he is a good speaker” ([Quintilian - Wikipedia](https://en.wikipedia.org/wiki/Quintilian#:~:text=that%20the%20perfect%20orator%20is,good%2C%20then%20one%20cannot%20be)). Rhetoric in the classical liberal arts was thus never purely technical; it was an ethical and civic art. The citizen-orator was expected to **engage in public life**, to marshal words as instruments of deliberation, leadership, and even moral improvement of the community.

Fast forward to the 21st century. The marble forum and its toga-clad senators have been replaced by digital arenas glowing on our screens. Instead of voice and gesture, we have code and algorithms. And yet, the spirit of Cicero finds an unlikely contemporary echo in what some are calling the rise of the **“citizen developer.”** In a college library in New England, a philosophy major whispers to her laptop, instructing an AI coding assistant to “make the colors more inviting” on a community outreach app she’s building. In a downtown co-working space, volunteers gather for a civic hackathon, brainstorming software solutions for local government. These modern scenes might seem far removed from the Roman Senate, but they share a common thread: people outside traditional power structures harnessing a medium (now code rather than speech) to shape their world. Today’s citizen developers – often students or hobbyists with liberal arts backgrounds – are using code as a new kind of **public discourse**. With the aid of artificial intelligence, they can increasingly “speak” in code without years of formal software training. The result is a democratization of software creation that feels uncannily similar to the democratization of public speaking in ancient republics.

## From Rhetoric to Code: Technology as Civic Expression

To understand this parallel, consider what rhetoric represented for millennia. It was more than fancy speech; it was the *engine of civic life*. In ancient Athens and Republican Rome, rhetoric was taught as a core of a liberal education precisely because it gave citizens the ability to persuade and participate. The forum and the Senate were venues where **words had power** – power to pass laws, to inspire armies, to forge consensus. That power was not taken lightly. Cicero famously maintained that an orator must serve the public good and **embody ethical responsibility**, uniting theory and practice “for the betterment of the state” ([Rhetoric - Wikipedia](https://en.wikipedia.org/wiki/Rhetoric#Rome#:~:text=eloquence%20%28eloquentia%29.,advanced%20the%20tradition%20by%20systematizing)). Quintilian went so far as to say that if one cannot be a genuinely good person, one cannot be a truly effective orator ([Quintilian - Wikipedia](https://en.wikipedia.org/wiki/Quintilian#:~:text=that%20the%20perfect%20orator%20is,good%2C%20then%20one%20cannot%20be)). The *art of rhetoric* in classical and humanistic traditions was thus about cultivating one’s voice as a citizen – a voice that could instruct, move, and bind together the community.

In the modern era, the means of civic influence have proliferated. The printing press allowed pamphleteers and essayists to become citizen-orators in print; radio and television carried voices to mass audiences; and the internet gave us blogs and social media activism. Each new medium expanded who could participate in public discourse. Now we are witnessing another medium take center stage: **software**. As legal scholar Lawrence Lessig observed, computer code, like law, increasingly determines how we live our lives – shaping what we can access, how we interact, and even what we believe. Lessig famously declared that “*code is law*,” meaning that software architectures function as a form of regulation and social control in the digital world ([Lawrence Lessig - Wikipedia](https://en.wikipedia.org/wiki/Lawrence_Lessig#:~:text=In%20computer%20science%20%2C%20,194%20in%20December%202006)). A social network’s algorithm, for example, governs the information diet of millions as surely as any policy or proclamation. In this light, writing code is not a purely technical act; it is a civic act. It creates systems that guide behavior, allocate attention, and organize collective life.

Ian Bogost, a scholar of media, coined the term **“procedural rhetoric”** to describe how software and games make arguments and express ideas through their rules and interactivity ([Procedural rhetoric - Wikipedia](https://en.wikipedia.org/wiki/Procedural_rhetoric#:~:text=The%20term%20,by%20adding%20or%20leaving%20out)). He defines it as “the art of persuasion through rule-based representations and interactions, rather than the spoken word, writing, images, or moving pictures” ([Procedural rhetoric - Wikipedia](https://en.wikipedia.org/wiki/Procedural_rhetoric#:~:text=The%20term%20,by%20adding%20or%20leaving%20out)). In other words, a computer program can *argue* or *advocate* by demonstrating a process or enabling an experience. A simulation game about city planning, for instance, implicitly persuades the player of certain values (perhaps the importance of budgeting or the trade-offs of zoning laws) by the way its code is structured. This is rhetoric, even if no words are spoken – it’s persuasion by design. We experience such “arguments” whenever we use a well-crafted app or digital tool that subtly influences our behavior. Think of a fitness app whose interface nudges you to walk more, or a civic petition platform that makes it easy to email your representative. The design and code of those tools are imbued with intent; they are created to convince or motivate you to act in certain ways.

If code is indeed a form of speech and persuasion, then who gets to be the speaker? Historically, software engineering has been a domain for specialists – an elite priesthood fluent in arcane programming languages. But that is rapidly changing. Just as the liberal arts sought to teach every free citizen the basics of rhetoric in Cicero’s time, today’s technologies are striving to teach (or rather, enable) every connected citizen to wield code. **Artificial intelligence is the great enabler** here. Consider GitHub Copilot, an AI “pair programmer” released in 2021. Trained on billions of lines of code, Copilot can auto-complete a software routine or generate a whole function from a mere comment or prompt. A user might type `// sort a list of names by length` in plain English, and Copilot will merrily produce the corresponding code in Python or JavaScript. What used to require careful study of syntax and algorithms now becomes a collaborative dialogue between human intent and machine suggestion. This is a fundamentally different model of creation – one might call it *rhetorical coding*, where expressing what you want (the *intent* or *purpose*) is more important than writing every character of the implementation.

## Intuitive Coding and the “Vibe” of Software

Perhaps the most intriguing aspect of AI-assisted development is how **intuitive** it can make the coding process. Some have begun to describe this as “vibe-based” coding – you convey the *feel* or *general idea* of what you want, and the AI does the heavy lifting of actual coding. The coding platform Replit, popular among students and hobbyists, explicitly champions this approach. Replit’s founders have spoken of “*vibe coding*” as the ability to build complete applications by simply describing them in natural language ([Replit - Wikipedia](https://en.wikipedia.org/wiki/Replit#:~:text=for%20,regardless%20of%20their%20technical%20background)). In fact, Replit’s system now allows a user to write, “I want a website that looks like a 90s arcade and shows local bus schedules,” and its AI agent will attempt to generate that very application. The goal is to **democratize application development**, making it accessible “regardless of [the user’s] technical background” ([Replit - Wikipedia](https://en.wikipedia.org/wiki/Replit#:~:text=for%20,regardless%20of%20their%20technical%20background)). In other words, if you can articulate an idea in your native tongue – if you can describe the vibe – you can materialize a piece of software.

This shift is analogous to moving from laboriously chiseling letters into stone to simply dictating to a scribe. It lowers the barrier between *conception* and *execution*. For liberal arts students, who are trained in articulation, storytelling, and critical thinking, this is a golden opportunity. Suddenly, code becomes another medium of expression, **closer in spirit to essay writing or public speaking than to traditional software engineering**. A student of history with an idea for an interactive map no longer has to either shelve the idea or hand it off to a tech major; with tools like Replit or Copilot, she can prototype it herself by describing what she wants. The process can feel almost like brainstorming with an editor or rehearsing with a debate coach. You try a prompt, see the result, refine your instructions, and gradually **coax a persuasive product into existence**.

Crucially, these AI coding tools don’t just crank out code – they engage in a back-and-forth with the creator. In that sense, they function like the *audience* or *collaborator* in classical rhetoric, providing immediate feedback. Much as an orator might read the room and adjust tone or argument on the fly, a modern citizen developer can iteratively adjust their prompts based on the software’s behavior. If the app “feels” off – maybe the interface is too cluttered or the tone of a chatbot is too stern – the creator tweaks the description (“make it friendlier,” one might tell the AI). The feedback loop is quick and conversational. This encourages a **“try it and see” approach**, an experimentation quite akin to drafting paragraphs in an essay or practicing different phrasings in a speech. The **intuitive, almost conversational nature** of vibe-based coding means that those with strong communication skills (say, a poet, or a political science major used to framing arguments) often excel at it. They treat the AI as an audience to persuade or a partner to dialogue with, rather than a blunt instrument. And in doing so, they imprint their humanistic perspective on the software being created.

## The Citizen Developer as the New Orator

Every new technology brings with it new cultures of use. The rise of the citizen developer is tied to the growth of communities and practices that mirror earlier forms of civic participation. One emblematic example is the proliferation of **hackathons** and civic tech workshops. These are typically informal gatherings where people from various backgrounds – not just professional coders – come together to build solutions for their community. Some are students, some are designers or data enthusiasts, and many proudly hail from outside the traditional tech industry. What unites them is a sense of civic mission and creative collaboration. If Cicero’s forum had marble benches and scrolls, today’s civic hacking spaces have whiteboards plastered with sticky notes, laptops emblazoned with stickers, and perhaps pizza boxes fueling late-night problem-solving. It’s a different aesthetic, but the *ethos* of civic engagement rhymes with the old: citizens stepping up to solve public problems, using the lingua franca at hand – which in our time includes code.

([File:Wikimedia Hackathon 2024 - Group photo, 360 cam.jpg - Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Wikimedia_Hackathon_2024_-_Group_photo,_360_cam.jpg)) *Participants at a Wikimedia hackathon in 2024 collaborate on software projects – a modern form of collective civic creativity.* These events and platforms exemplify how coding can be a **social, persuasive act** rather than a lone technical one. A team at a hackathon might build a prototype that visualizes city budget data, effectively making an argument for transparency through software design. Another group might craft a mobile app to coordinate neighborhood disaster relief, implicitly persuading users toward mutual aid. The **rhetorical intent** is embedded in these projects. And because the teams often include liberal arts students and self-taught coders alongside engineers, the solutions tend to blend technical ingenuity with humanistic insight. A psychology major might ensure an mental-health support app uses encouraging language, or an art student might design a user interface that emotionally resonates with elders. These contributions are as important as the code itself in persuading an audience to embrace the tool.

Beyond hackathons, an entire ecosystem of **civic tech initiatives** has emerged, blurring the line between professional developers and citizen volunteers. For instance, Code for America, a non-profit network often described as a “Peace Corps for geeks,” has mobilized thousands of volunteers to work on public-interest technology. These volunteers – many of them ordinary citizens with day jobs in completely different fields – partner with local governments to build digital services. As of recent counts, Code for America’s Brigade network included some 25,000 volunteers in 85 chapters across 41 states ([Code for America to strengthen local tech Brigade chapters with support from Knight Foundation | Philanthropy Network Greater Philadelphia](https://philanthropynetwork.org/news/code-america-strengthen-local-tech-brigade-chapters-support-knight-foundation#:~:text=There%20are%20now%2025%2C000%20Code,help%20address%20local%20civic%20issues)). They have created tools to help people find food assistance, expunge eligible criminal records, and access tax credits, among other socially impactful projects. The **scale** of this movement suggests a new norm: just as volunteering to clean a park or canvass for a cause became common civic behaviors in the 20th century, volunteering to build or tweak software for the public good is becoming a form of 21st-century civic engagement.

What’s striking is how often the most celebrated civic tech successes hinge on liberal arts sensibilities. Government technology is notoriously tricky not for lack of coding skills, but for lack of *user empathy* and clear communication. Here, citizen developers with humanistic training shine. They approach a welfare application website not just as a coding challenge, but as a narrative: What is the story of a single mother trying to get food stamps? Where might she feel confused or discouraged? Through that lens, they craft solutions that are persuading users in a gentle, service-oriented way: persuading them to trust the system, to complete the process, to claim their rightful benefits. An example: a volunteer team in California redesigned the interface for applying to food assistance (the GetCalFresh project) and managed to **cut the application time from 45 minutes down to under 10 minutes**, by simplifying language and workflow ([Code for America - Wikipedia](https://en.wikipedia.org/wiki/Code_for_America#:~:text=,8)). The result is not just a faster form – it’s an argument, embedded in software, that applying for help can be easy and dignified. The numbers bear out the persuasive impact: more people completed the application, leading to thousands of families getting aid they might have otherwise missed ([Code for America - Wikipedia](https://en.wikipedia.org/wiki/Code_for_America#:~:text=,8)). It’s Cicero’s *betterment of the state*, achieved not through oratory in the Senate, but through empathetic design and intuitive coding.

## Liberal Arts Values in the Age of AI Coding

Steve Jobs, reflecting on his own path, once said he realized the importance of people who could stand “at the intersection of the humanities and the sciences” ([Steve Jobs - Wikipedia](https://en.wikipedia.org/wiki/Steve_Jobs#:~:text=,what%20I%20wanted%20to%20do)). That intersection is exactly where the citizen developer thrives. The liberal arts, with their emphasis on context, ethics, and expression, ensure that technology is not developed in a vacuum. **AI-assisted coding** can churn out applications at an astonishing speed, but it falls to human creators to decide *which* applications ought to be made and *why*. A classical education trained orators to ask: *Quidquid agis, prudenter agas et respice finem* – Whatever you do, do it wisely and consider the end (outcome). Likewise, a liberally educated coder might ask: What problem am I solving? Whose perspective is missing in this dataset? Am I persuading users toward something beneficial, or merely exploiting their attention? These questions echo rhetorical and ethical principles that go back to Aristotle’s emphasis on ethos (character) and pathos (emotional understanding) as complements to logos (logic).

In practical terms, we are already seeing liberal arts students shape technology in ways that differ from the conventional approaches of engineering alone. A literature student uses an AI code assistant to create an interactive story app that engages local youth in civics, embedding elements of mythology to draw parallels between ancient heroism and modern citizenship. A sociology major, frustrated by bureaucratic jargon on a city website, leverages a no-code platform to build a plain-language guide for renters facing eviction, effectively turning dense statutes into a persuasive, accessible dialogue. These projects are **rhetorical acts** as much as they are technical ones. They seek to persuade or empower an audience (the public) and they do so by merging content with form – the age-old rhetorical marriage of *what is said* with *how it is conveyed*.

The presence of AI in the coding process does not diminish the importance of those humanistic touches; in fact, it elevates them. When routine coding is handled by Copilot or a similar tool, the human developer is freed to focus on higher-level decisions: the metaphors in the user interface, the tone of notifications, the fairness of an algorithm’s outcomes. These are areas where liberal arts training is invaluable. It’s as if the citizen developer becomes less of a mechanic and more of an **author or architect**, responsible for the vision and integrity of the creation. The AI is a powerful collaborator, but it lacks purpose without guidance. It cannot (at least not yet) define the civic problem to solve or ensure the solution aligns with community values. That remains the role of the human, and it requires the broad, contextual thinking that a liberal education cultivates.

Moreover, liberal arts folks bring a healthy skepticism and ethical reflection to the tech table. They recall that **persuasion can be a double-edged sword** – a great speech can rally a republic or, in the wrong hands, undermine it. Similarly, persuasive software can empower or manipulate. The citizen developer must grapple with this, much as Cicero grappled with the moral responsibilities of the orator. Here we see the revival of an old debate: in antiquity, Plato famously worried that rhetoric without philosophy was dangerous flattery, while Aristotle and Cicero argued that when guided by virtue, rhetoric was essential to justice. Today, one might replace *rhetoric* with *AI-assisted development*. Will our new tools be used for mere profit and propaganda, or for uplifting and uniting? The answer will depend on who wields them and the values they embody. By infusing the creation of technology with liberal arts perspectives, we tilt the balance toward tools that are **humane and dialogic** rather than merely efficient or addictive.

## A New Chapter in Expressive Power

In a sense, we are witnessing a new chapter in the evolution of expressive power. Imagine explaining to Cicero that one day citizens would not only speak in forums and publish pamphlets, but also write “algorithmic speeches” – programs – that could spread across the world in seconds and subtly influence millions. He might find the concept alien, yet he would surely recognize the stakes. The ability to create software is a kind of superpower of expression, one that must be guided by wisdom and civic virtue just as the oratory of old was. The encouraging news is that this power is moving into more hands, and not just hands trained in engineering labs, but those shaped in libraries, studios, and seminar rooms where the liberal arts live. A classics student might write an app that brings a neighborhood together for mutual aid, essentially *engineering community spirit* through a few hundred lines of code. That is a profoundly rhetorical act.

This convergence of liberal arts and technology also heralds a cultural shift. We no longer draw a hard line between “techies” and “fuzzies,” between the coder and the storyteller. The citizen developer is a hybrid. In them, the Renaissance ideal of the well-rounded individual finds a modern form: comfortable with both Homer and HTML, able to quote James Baldwin and debug a Python script. They see no contradiction in doing so, because for them code is just another medium to **“speak” to society**. And importantly, they are not working in isolation. Just as the best ideas in a republic arose from spirited public debate, the best citizen development often arises from open collaboration and sharing. Platforms like GitHub and Replit are not just tools; they are gathering places, much like the agora of Athens. One can post a snippet of code and get feedback, or fork someone else’s civic project and adapt it to a new city. In these interactions, a kind of *digital rhetorical training* happens informally – people learn how to frame their problems, how to consider user ethos, how to stir excitement around an open-source project’s mission.

We might recall how, in the late 18th century, pamphleteers like Thomas Paine used the relatively new technology of mass printing to fuel democratic revolution with plain, powerful prose. In our era, perhaps a savvy citizen developer will use an AI-powered platform to distribute a civic app that transforms public opinion or mobilizes a community for positive change. The tools differ, but the heart of the matter is the same: **participation, persuasion, and agency**. The liberal arts have always been about nurturing those qualities – about empowering individuals to reflect on society and then express themselves in a way that impacts others. Now, with intuitive AI coding at their disposal, those individuals can move fluidly between writing a persuasive essay and writing a persuasive algorithm.

It’s fitting to think of this moment not as a rupture with the past, but as a continuum. The *citizen orator* of Cicero’s day and the *citizen developer* of today are kindred spirits across time. Both believe that **ideas matter in the polis**, and both seek to give those ideas tangible form – whether in a rousing speech or an engaging app. Each operates within a set of tools and norms: Ciceronian rhetoric had its canons and tropes; modern coding has its frameworks and APIs. In both cases, the truly impactful creators are those who master the toolset but also transcend it, infusing their work with imagination, ethics, and a sense of the audience.

The classroom, too, is evolving to reflect this synthesis. We see computer science courses assigning readings from moral philosophy, and humanities courses incorporating basic coding projects. A literature seminar might have students use a no-code tool to build a website curating civic poems, while a political science class might employ data visualization code (made easier by AI assistants) to support an argument about voter turnout. These aren’t diversions from the subject matter; they are expansions of it. They acknowledge that to be literate in the 21st century is to be conversant in multiple modes of expression – including digital ones. **Coding, assisted by AI, is joining writing and speaking as a fundamental expressive literacy.** And just as we teach writing and speaking in a human context, imbued with critical thinking about audience and purpose, we will teach this new literacy in a human context too.

In the end, the true measure of this citizen developer movement will be in its alignment with the public interest and its ability to uphold the democratic spirit of discourse. The early signs are promising. When everyday people can create tech solutions, we get innovations that institutional players often overlook. We get apps that actually *talk* the people’s language (sometimes literally, through intuitive design). We get a technology ecosystem that is a bit more pluralistic, a bit more representative of the full tapestry of talents and perspectives in society. It’s as if the art of rhetoric has found a new canvas. There is a certain poetry in this: Cicero’s heirs may not stand in the Forum wearing togas, but they sit in coffee shops and dorm rooms, laptop at the ready, weaving together words and code. Their audience is not a crowd of senators but perhaps the users of a platform or the citizens of a city who will feel the effects of an app built in a weekend. They persuade not by florid orations, but by crafting digital experiences that inform, assist, and inspire.

The liberal arts tradition has always maintained that education should produce not just skilled workers, but **active, thinking citizens**. In an age when software shapes so much of our lives, it stands to reason that active citizenship extends to the digital realm. The emergence of intuitive AI coding platforms means that a concerned citizen with a liberal arts mindset can directly **express civic ideas in the form of software**, much as a pamphleteer would have in the age of print. This is a power shift – quiet but profound – putting more of the keys to innovation in the hands of the many. It suggests a future where technology is not only user-friendly but *citizen-friendly*, shaped by a wider swath of society and guided by timeless principles of justice and eloquence.

As we turn this new page in history, the classical echoes remind us to proceed with both boldness and care. The *citizen developer* should aspire, in Quintilian’s phrasing, to be a good person coding well. The apps and algorithms we create are in effect speeches we deliver to our communities – they make their case through usability, through impact, through the values they embed. Will those speeches ring with truth and promote the common good? With more liberal arts voices joining the chorus of coders, there is reason to hope so. The art of persuasion has survived the leap from forum to Facebook, from parchment to Python. It changes form, yes, but its core mission endures: to connect with others, to reason together about how we should live, and to spur collective action. The stage is set for a renaissance of rhetoric in this digital age, led by citizen developers who code with the soul of poets and the conscience of philosophers. In their hands, **code becomes a language of civic poetry**, and every program a potential soliloquy for a better society.