The profession of programming has undergone radical transformation since the 1940s, evolving from direct machine control to AI-assisted development in ways that fundamentally validate Marx’s analysis of technology under capitalism. This comprehensive examination reveals how each technological shift has intensified both worker productivity and capitalist value extraction, while creating new forms of alienation that extend Marx’s insights into the digital age.
Programming labor today exhibits the central contradiction Marx identified in capitalist technology: tools that could liberate human creativity are instead deployed to intensify exploitation. AI assistants boost programmer productivity by 55.8%, yet salary growth lags far behind these gains, while tech companies maintain profit margins exceeding 75%. Simultaneously, abstraction layers that promise to free programmers from tedious work create new forms of alienation from both the labor process and creative output.
The evidence demonstrates that software development operates within what scholars term “platform capitalism” - an intensified form of monopoly capitalism where big tech companies control the fundamental infrastructure programmers depend on, from cloud services to development tools to AI assistants. This represents a qualitatively new stage of capitalist control over the means of production, extending into the realm of mental labor and creative work in unprecedented ways.
Historical evolution reveals intensifying contradictions
The transformation of programming work from binary machine code to natural language AI assistance follows a clear trajectory of increasing abstraction and capitalist subsumption of mental labor. Each technological transition - from machine code to assembly language to high-level programming languages to modern frameworks to AI assistants - has followed the pattern Marx identified in industrial machinery: apparent worker empowerment coupled with deeper structural subjugation to capital.
The machine code era (1940s-1950s) represented programming’s closest approximation to Marx’s ideal of unalienated labor. Programmers maintained intimate knowledge of computer hardware operations and direct control over the complete production process. Individual programmers handled everything from hardware configuration to software implementation, with minimal division of labor. While computers were scarce and expensive, owned primarily by large institutions, programmers retained significant autonomy over how these machines operated.
Assembly language marked the beginning of what Marx called “real subsumption” of programming labor under capital. The introduction of symbolic representation created the first abstraction layer between programmer and hardware, beginning a process Brazilian scholars term “a tecnologia sequestra a capacidade total do trabalhador” (technology kidnaps the worker’s total capacity). This transition initiated the hierarchical division between system programmers working closer to hardware and application programmers, fragmenting previously holistic knowledge.
High-level programming languages accelerated this abstraction process while exemplifying Marx’s concept of “moral depreciation” of skills. FORTRAN, COBOL, C, and subsequent languages made programming more “efficient” while reducing programmer control over underlying production processes. Previous knowledge became obsolete not through wear but through technological advancement, forcing continuous reskilling to remain employable.
The modern frameworks era (1990s-2010s) completed the industrialization of programming work. Object-oriented programming, web frameworks, and software development kits created unprecedented abstraction levels where programmers increasingly worked with pre-built components rather than creating from scratch. This era exhibits what one analysis characterizes as capitalism having “killed the craft of software development” through extreme specialization - frontend versus backend developers, database specialists, DevOps engineers - each representing fragments of once-holistic programming knowledge.
AI assistance creates productivity without proportional compensation
Contemporary AI-assisted programming represents the automation of mental labor itself, fulfilling Marx’s prediction about machinery making workers “superfluous.” Controlled studies demonstrate that AI programming assistants like GitHub Copilot increase task completion speed by 55.8% while improving completion rates from 70% to 78%. Programmers using AI tools report 46% of their code being generated automatically, with 73% experiencing improved flow states and 87% preserving mental effort during repetitive tasks.
However, these dramatic productivity gains fail to translate into proportional compensation increases, revealing substantial surplus value extraction. While AI tools multiply individual programmer output by 1.5-3x depending on experience level, software developer salary growth has decelerated from 20-25% annually in 2015-2020 to just 5-10% in 2024-2025. Meanwhile, software industry gross margins remain consistently between 75-85%, with operating margins of 20-35% for mature companies.
The mathematics of exploitation are stark: average software developers earn 180,000-200,000 total compensation), while generating 1,200,000 in revenue for major tech firms. This represents a surplus value extraction ratio between 3:1 and 6:1, indicating that workers capture only 15-30% of the value they create.
Labor’s share of tech sector value added has declined from 65-70% in the 1960s-1970s to just 45-50% in the 2020s - a 20-25 percentage point erosion that coincides with increased automation and platform consolidation. McKinsey research suggests AI could boost global GDP by $1.5 trillion, yet this value flows predominantly to capital owners rather than the programmers whose enhanced productivity enables these gains.
Platform capitalism establishes new relations of production
Software development today operates within fundamentally transformed relations of production that extend Marx’s analysis into digital infrastructure. Big tech companies function as “digital landlords” controlling essential infrastructure - from Amazon Web Services cloud computing to Google’s Android platform to Microsoft’s development tools. This represents qualitatively new forms of monopolistic control over the means of production.
Programmers appear to “own” basic tools (personal computers, access to open-source software) yet remain structurally dependent on platform capitalism’s infrastructure. This creates what Italian theorist Lorenzo D’Auria terms “cognitive capital” - a system where knowledge accumulation and capital accumulation operate simultaneously through the same labor processes. Programmers generate value through their intellectual work while that same work immediately becomes capital’s means of controlling future programming labor.
The ownership structure of contemporary software development reveals multiple layers of capitalist control. Hardware increasingly depends on cloud infrastructure controlled by major tech corporations. Development tools, while often “free,” operate within proprietary ecosystems that extract value through platform fees and data collection. AI assistants like GitHub Copilot and ChatGPT are entirely controlled by major tech corporations, creating new dependencies where programmers’ enhanced productivity directly benefits capital owners.
Intellectual property regimes function as mechanisms for converting programmers’ living labor into “dead labor” that can be owned and controlled by capital. This creates artificial scarcity around infinitely reproducible digital goods, enabling rent extraction from what should be collective human knowledge. The platform economy exhibits what Marx called “antediluvian” forms of accumulation - secondary exploitation through rent-seeking rather than direct production of surplus value.
Software challenges traditional labor theory of value
Software as a product presents unique challenges to Marx’s labor theory of value while ultimately confirming its insights. Software exhibits non-rivalrous consumption (infinite use without depletion), near-zero marginal reproduction costs, and network effects where value increases with adoption. These characteristics create contradictions between use-value and exchange-value that are artificially maintained through intellectual property laws and platform control.
Programming labor operates simultaneously at multiple levels of abstraction, creating what scholars term a “double helix” where capital accumulation and knowledge accumulation operate through identical processes. The same programming work produces both marketable software commodities and accumulated knowledge that becomes capital’s means of production. This represents an intensification of Marx’s insight about workers producing the very conditions of their own exploitation.
AI-assisted programming fundamentally alters the concept of “socially necessary labor time” in software development. AI tools reduce programming time by 30-55% for typical projects, with task-specific reductions of 70-90% for boilerplate code generation and 50-70% for documentation creation. This rapid reduction in socially necessary labor time creates deflationary pressure on software prices in competitive markets while increasing profit margins where market power exists.
The labor theory of value applied to AI reveals that machine learning systems trained on freely available code repositories essentially “plagiarize the general intellect” - appropriating the collective knowledge of programming communities to create tools that then extract value from individual programmers’ enhanced productivity. This represents what researchers term “fictitious knowledge” analogous to Marx’s “fictitious capital.”
Alienation assumes new forms in digital labor
Marx’s four forms of alienation manifest distinctively in contemporary programming work, with AI tools creating both intensifying and potentially liberating effects depending on their implementation within capitalist or alternative frameworks.
Alienation from the product of labor has intensified through multiple mechanisms. The gig economy increasingly dominates tech work, with 36% of the US workforce performing some form of gig work by 2022 and programming becoming heavily freelance and contract-based. Platform-mediated work breaks projects into “discrete microtasks” where programmers may not “even know that they are labeling images for an image database, much less what the database is for.” AI code generation creates situations where programmers become “reviewers of AI’s work” rather than creators, leading many to report that AI is “starting to kill my enjoyment for my work.”
Alienation from the labor process deepens as abstraction layers hide underlying computational processes, creating what Marx called “mystification” of production. AI’s “black box” nature means programmers increasingly work with systems they cannot understand or control, becoming “appendages” to machine learning systems. The “agentic layer” concept describes how AI creates new forms of abstraction that distance programmers from their actual creative contribution.
However, contradictory tendencies exist. Some researchers argue AI could enable “liberatory alienation” by eliminating tedious tasks and allowing focus on uniquely human qualities like creativity and complex problem-solving. Open source development provides a crucial counter-example, reducing multiple forms of alienation by maintaining programmer control over both the production process and creative output.
The open source movement demonstrates how collaborative, transparent development processes can reduce alienation while creating genuine communities of practice. The GNU General Public License acts as what one analysis terms a “benign, liberating virus” ensuring that work “benefits the whole world and remains free,” contrasting sharply with proprietary development where workers remain isolated and controlled.
Resistance emerges through collective organization
Despite intensifying exploitation, programming labor exhibits growing recognition of shared class interests and collective organization. Tech worker organizing efforts - from Apple retail workers to Google contractors to game developer unions - represent awakening class consciousness among previously individualistic “knowledge workers”. These movements challenge the ideology that portrays tech workers as autonomous entrepreneurs rather than employees subject to capitalist labor relations.
Alternative organizational models provide prefigurative examples of post-capitalist programming work. Worker-owned software cooperatives, platform cooperatives for freelance developers, and community-controlled technology development demonstrate possibilities for democratic control over both digital tools and labor processes. The free software movement shares “much in common with the trade union movement” as both represent efforts toward “building a fair and just society” through collective control over the conditions of work.
Brazilian academic sources emphasize how technological education could potentially overcome alienation if organized democratically, but under capitalism becomes another tool for producing specialized workers for capital. This suggests that the technical skills programmers develop contain liberatory potential that remains constrained by capitalist social relations.
Contemporary implications and future trajectories
The evidence demonstrates that programming under platform capitalism represents an intensification rather than transcendence of classical Marxist dynamics. Software development validates Marx’s predictions about technology under capitalism: deskilling through abstraction, intensification of work pace, increased alienation from creative processes, and the deployment of potentially liberating tools to further exploit workers.
The emergence of AI programming assistants fulfills Marx’s insight that machinery acts as “a power inimical” to workers, “always on the point of making him superfluous.” While AI could theoretically eliminate repetitive programming tasks and enable focus on creative problem-solving, its capitalist deployment serves primarily to reduce labor costs, intensify work pace, and create new forms of surveillance through code analysis.
The contradiction between technology’s liberatory potential and its capitalist application has never been sharper. AI tools could enable unprecedented creative collaboration and democratize programming skills, yet their ownership by major tech corporations ensures these benefits flow primarily to capital owners. The same technologies that could reduce working hours and eliminate drudgery are instead deployed to extract more value from programmers’ mental labor.
Understanding programming through Marxist analysis reveals both the continued relevance of Marx’s critique and the urgent need for collective control over digital infrastructure and knowledge production. The digital economy has not overcome the fundamental contradiction between social production and private appropriation but has extended it into new domains of human creativity and intellectual work.
Future developments in AI-assisted programming will likely intensify these contradictions, potentially creating both greater opportunities for liberation through technological cooperation and deeper forms of exploitation through automated surveillance and control. The outcome depends fundamentally on whether programmers and other digital workers can develop effective collective organization to claim democratic control over the digital tools that increasingly shape their labor and lives.
Conclusion: Marx in the age of algorithms
This analysis demonstrates that classical Marxist concepts - properly understood and applied - provide powerful analytical tools for understanding contemporary software development. Far from being obsolete, Marx’s insights reveal how digital technologies serve to deepen rather than overcome capitalist exploitation, while also illuminating possibilities for alternative forms of technological organization that could support human flourishing rather than capital accumulation.
Programming work today embodies the central contradiction of capitalism: the development of productive forces that could liberate humanity from scarcity and toil, deployed instead to intensify exploitation and accumulation. AI assistants that could democratize programming skills become tools for extracting more value from mental labor. Platforms that could enable global cooperation become mechanisms for monopolistic control. Knowledge that should belong to humanity becomes the private property of tech corporations.
Yet this same analysis reveals spaces of resistance and alternative possibility. Open source development, tech worker organizing, and platform cooperatives prefigure forms of technological cooperation that transcend capitalist social relations. The task for programmers and digital workers is developing collective strategies to realize technology’s liberatory potential while confronting the structural forces that constrain it.
Marx’s analysis remains profoundly relevant precisely because the contradictions he identified in industrial capitalism have intensified rather than resolved in the digital age. Understanding programming through Marxist theory illuminates both the depth of contemporary exploitation and the possibilities for its transcendence through collective struggle for democratic control over the digital tools that increasingly shape human society.