Factory Discipline vs Platform Algorithms: The Evolution of Control

Series: Industrial Revolution & Data Revolution #02/05 | Read time: 35 min | Python (NumPy, Pandas, Matplotlib)

Author: Wina @ Code & Cogito

When Taylor Picked Up the Stopwatch

1. The Bethlehem Steel Works, Philadelphia.

Frederick Winslow Taylor stood beside a laborer named Henry Noll — though in his published account, Taylor gave him the pseudonym “Schmidt,” a name that has become a byword for the dehumanization of industrial work.

Schmidt’s job was simple in description, brutal in execution: pick up a 27.5-pound pig of iron from the ground, carry it up a plank, and load it onto a railcar. Repeat. All day. Every day.

The typical worker loaded about 12.5 long tons per day. Taylor believed this was inefficient.

He approached Schmidt with a proposition: “If I can show you how to earn $1.85 a day instead of $1.15, would you be interested?”

Schmidt was interested.

Taylor began timing everything:
– Bending to grasp the pig iron: 0.8 seconds
– Lifting: 1.2 seconds
– Walking to the railcar: 6.4 seconds
– Depositing the pig: 0.6 seconds
– Walking back: 5.8 seconds
– Rest period: ? seconds

Through careful measurement, Taylor calculated that Schmidt should work for twenty-six minutes per hour and rest for thirty-four. The counterintuitive ratio — more rest than work — was the key. Fatigue accumulation was nonlinear. The optimal strategy was not to push harder, but to pulse.

Result?

Schmidt’s daily output rose from 12.5 tons to 47.5 tons. A 280% increase. His wages rose from $1.15 to $1.85.

Taylor called it “Scientific Management.”

His critics called it “turning men into machines.”

Harry Braverman, writing in Labor and Monopoly Capital (1974), would later argue that Taylor’s real achievement was not efficiency but expropriation — the systematic transfer of knowledge from the worker’s hands and head to the manager’s clipboard. Before Taylor, the skilled worker owned something valuable: craft knowledge. After Taylor, that knowledge belonged to the firm.

1. San Francisco.

Uber’s algorithm was analyzing a driver named Travis’s data:
– Average time to accept a ride request: 2.3 minutes
– Completion rate: 92%
– Cancellation rate: 8%
– Passenger rating: 4.6/5.0
– Peak hour availability: 45%

The algorithm determined: Travis’s efficiency was below the market average.

The system pushed a notification:

“Your acceptance rate is below the average for your area. Improving your acceptance rate can help you receive more ride requests!”

Travis did not know:
– What the “average” actually was
– How many other drivers received the same message
– What the consequences of ignoring it would be

Uber called it “Experience Optimization.”

Critics called it “Algorithmic Exploitation.”

Alex Rosenblat, in her ethnographic study Uberland (2018), documented how Uber’s interface was carefully designed to make drivers feel like independent entrepreneurs while subjecting them to a degree of managerial control that would have made Frederick Taylor blush.

Taylor and Uber, separated by 116 years, were doing the same thing:

Using mathematical models to control the labor process.

But there is one crucial difference:

Taylor’s control was visible — a foreman stood beside you with a stopwatch. You knew you were being watched.
Uber’s control is invisible — an algorithm operates behind the screen. You do not know the rules.

In this article, I use Python to simulate both the factory management system and the platform algorithm, compare the two control mechanisms, analyze the mathematical structure of the gig economy, and confront a fundamental question: When algorithms replace foremen, are workers more free — or less?

Taylorism: The Birth of Scientific Management

Before Taylor, factories operated on tradition and rule of thumb.

Under the traditional model, foremen assigned work based on experience. Workers completed tasks based on craft knowledge. Efficiency was a matter of luck. Standards did not exist.

Taylor’s verdict: This is unscientific.

The Four Principles of Scientific Management

Principle 1: Time and Motion Study

Decompose every job into its smallest constituent motions. Time each one.

Example: Shoveling coal
– Bend: 0.5 seconds
– Scoop: 1.8 seconds
– Turn: 0.7 seconds
– Empty into furnace: 1.2 seconds
– Repeat

Discovery: Workers using shovels that were too large or too small were both inefficient. The optimal shovel load was approximately 21 pounds. Not 15. Not 30. Twenty-one.

Result: Providing standardized tools increased efficiency by 300%.

Principle 2: Standardized Processes

Every task has a “one best way.” Workers were forbidden from improvising, forbidden from deviating from the prescribed method, required to execute precisely according to the “scientifically” determined procedure.

Principle 3: Scientific Selection and Training

Not “anyone can do any job,” but “select the person best suited to each task” — physical tests, skill assessments, and, implicitly, tests of compliance.

Taylor’s own words:

“In our scheme, we do not ask the initiative of our men. We do not want any initiative. All we want of them is to obey the orders we give them, do what we say, and do it quick.”

This is the passage Braverman seized upon. Taylor was not merely optimizing output. He was redesigning the relationship between knowledge and labor — extracting what workers knew, codifying it, and returning it to them as instructions they were forbidden to question.

Principle 4: Separation of Planning and Execution

Management is responsible for “thinking” (planning, optimizing).
Workers are responsible for “doing” (following instructions).

Simulating the Taylorist Factory

The core logic of a Taylorist factory can be captured in a concise model: standardized task times, a distribution of worker efficiency, and the unavoidable cost of supervision.

class TayloristFactory:
    """Simulates a 1900s Taylorist factory"""
    def __init__(self, n_workers=50, work_hours=10):
        self.n_workers = n_workers
        self.work_hours = work_hours
        self.standard_times = {'task_A': 3.2, 'task_B': 5.1, 'task_C': 4.7, 'rest': 10.0}
        self.worker_efficiency = np.random.normal(1.0, 0.15, n_workers)
        self.supervisor_ratio = 0.1  # 1 foreman per 10 workers

    def simulate_day(self):
        total_minutes = self.work_hours * 60
        tasks_completed, worker_fatigue = [], []
        for w in range(self.n_workers):
            efficiency = self.worker_efficiency[w]
            minutes_worked, tasks, fatigue = 0, 0, 0
            while minutes_worked < total_minutes:
                for task_name, standard_time in self.standard_times.items():
                    if task_name == 'rest':
                        minutes_worked += standard_time
                        fatigue -= 5
                    else:
                        minutes_worked += standard_time / efficiency
                        tasks += 1
                        fatigue += 2
                    if minutes_worked >= total_minutes: break
            tasks_completed.append(tasks)
            worker_fatigue.append(max(0, fatigue))
        return np.array(tasks_completed), np.array(worker_fatigue)

Full code available on GitHub (free version with base analysis): View complete code ->

The simulation results reveal the internal tensions of Taylorism:

Top left: Worker output under standardized processes still follows a normal distribution, with a coefficient of variation of approximately 15%. Top right: Output and fatigue are positively correlated — the most productive workers pay the greatest physical price. Bottom left: A fully Taylorized standardized workday schedule. Bottom right: Supervision costs as a significant proportion of total costs.

The core logic of Taylorism emerges from the data: standardized processes genuinely reduced worker autonomy. Stopwatch timing meant every motion was precisely quantified. The separation of planning and execution meant workers no longer needed to think. But all of this required a substantial layer of foremen to enforce, and supervision costs consumed a significant share of total expenditure.

Taylorism’s achievement:

Productivity increased dramatically. In some factories, efficiency improved by 200-400%.

Taylorism’s price:

Workers became, in Braverman’s phrase, “appendages of the machine.”

116 Years Later: The Platform Algorithm Does the Same Thing

1. Uber’s data scientists were building a driver management system.

Objective: eliminate the foreman. Let the algorithm optimize automatically.

Uber’s Four Control Mechanisms

Mechanism 1: Surge Pricing

When demand exceeds supply, prices rise automatically. The stated purpose: attract more drivers, reduce demand, balance the market.

What the driver does not know: When the surge will end. How the multiplier is calculated. Why their zone is surging while the next zone is not.

Mechanism 2: Acceptance Rate Monitoring

The system tracks each driver’s acceptance rate, cancellation rate, and rating. Acceptance rate too low? The system reduces dispatches.

What the driver does not know: What “too low” means. How much a single rejection costs. How to recover.

Mechanism 3: The Rating System

Passengers rate drivers on a 1-5 star scale. Below 4.6? Risk of deactivation.

What the driver does not know: Which passenger gave the low rating. Why they gave it. How to appeal.

This is the structure Rosenblat identified as “soft control” — the platform never explicitly threatens. It simply adjusts the flow of opportunities. The effect is identical to a foreman’s threat of dismissal, but it arrives in the form of a cheerful notification rather than a shouted command.

Mechanism 4: Gamification

“Just 3 more rides to complete your daily goal!” “Drive 1 more hour to earn a $50 bonus!”

Behavioral psychology, deployed at scale, to keep drivers on the road longer than they otherwise would choose.

Simulation Results

We built a UberAlgorithm model simulating 50 drivers over 10 hours, analyzing income distribution, surge pricing effects, and rating-based filtering.

Top left: Driver income follows a right-skewed distribution; the mean exceeds the median — a few high-performers pull the average up. Top right: Drivers with ratings below 4.6 see income collapse to zero; the rating system creates a hard threshold. Bottom left: Drivers with acceptance rates below 80% are similarly penalized. Bottom right: Surge pricing pushes fares 1.5-2.5x during peak hours (8-9am, 5-7pm).

The core logic of Uber’s algorithm is equally legible: surge pricing inflates fares during high-demand periods, ratings and acceptance rates determine dispatch priority, gamification mechanisms use psychological manipulation to extend working hours — and the supervision cost is effectively zero. The algorithm performs every function the foreman once did, at a fraction of the cost.

The income Gini coefficient exceeds 0.4, indicating “high inequality.” The algorithm is not merely a management tool. It is an inequality-generating machine.

Uber’s achievement:

Zero supervision cost. No foremen needed. The algorithm optimizes automatically.

Uber’s price:

Drivers become, in the gig economy vernacular, “servants of the algorithm.”

Taylor vs Uber: Two Control Systems Compared

Let us compare the two systems with data.

We quantify five dimensions of control — supervision cost, worker autonomy, actual control intensity, income volatility, and information asymmetry — and visualize the results:

Five-dimensional comparison: Uber’s supervision cost is one-tenth of Taylorism’s, but actual control intensity is higher (9 vs 8), information asymmetry has surged (80 vs 30), and income volatility has doubled (45% vs 20%).

The comparison reveals a central paradox: Uber’s supervision cost is one-tenth of Taylorism’s, but its actual control intensity is greater. Information asymmetry has jumped from 30 to 80 on our scale. Income volatility has doubled from 20% to 45%. Drivers feel freer (they choose their hours), but they are actually more controlled (the algorithm monitors everything).

The striking parallels:

The critical difference:

Taylorism: Control is visible
– You see the foreman watching you
– You hear the stopwatch clicking
– You know what the standard is

Uber: Control is invisible
– You do not know how the algorithm scores you
– You do not know why dispatches have decreased
– You do not know where the threshold lies

Which is worse?

There is a case — articulated by labor scholars from Braverman to Jamie Woodcock — that Taylorism was at least “honest exploitation.” The foreman stood in front of you. The power relationship was undisguised. You could organize against it. You could strike.

Uber is what we might call “invisible exploitation.” You believe you are an “independent contractor,” a “micro-entrepreneur.” In reality, you are a component in an optimization function you cannot see, governed by rules you cannot access, subject to penalties you cannot predict.

The most effective form of control is the kind that does not feel like control.

The Mathematics of the Gig Economy: Flexibility vs Stability

Uber says: We give drivers “flexibility.”

Critics say: That is a euphemism for “precarity.”

Guy Standing’s The Precariat: The New Dangerous Class (2011) coined a term for the growing population of workers in exactly this position — people who have lost the stable employment, social protections, and predictable income that characterized the postwar settlement, and gained in return a hollow “freedom” that amounts to perpetual uncertainty.

Let us analyze this mathematically.

Income Volatility Model

We built a gig economy income model simulating 100 workers over 365 days. Traditional employment assumes a fixed daily wage of $100. The gig economy overlays four sources of volatility: demand fluctuation (weekends high, weekdays low), personal efficiency variation (fatigue, illness), platform algorithm fluctuation (rating changes, dispatch adjustments), and competitive pressure (number of other drivers online).

class GigEconomyModel:
    """Simulates gig economy vs traditional employment income differences"""
    def simulate_gig_economy(self):
        base_daily = 100
        earnings = np.zeros((self.n_workers, self.n_days))
        for w in range(self.n_workers):
            for d in range(self.n_days):
                day_of_week = d % 7
                demand = np.random.uniform(1.2, 1.5) if day_of_week in [5,6] \
                         else np.random.uniform(0.8, 1.1)
                efficiency = np.clip(np.random.normal(1.0, 0.15), 0.5, 1.5)
                algorithm = np.clip(np.random.normal(1.0, 0.2), 0.6, 1.4)
                competition = np.random.uniform(0.85, 1.15)
                earnings[w, d] = max(0, base_daily * demand *
                                     efficiency * algorithm * competition)
        return earnings

Simulation results:

Top left: Annual income trajectory for a single worker — blue line (traditional employment) is flat as glass; red line (gig economy) oscillates violently. Top right: Income distribution comparison; the gig economy’s long tail extends toward low-income territory. Bottom left: Risk-return scatter plot — gig workers bear substantially higher risk for similar average returns. Bottom right: Coefficient of variation comparison; gig economy income volatility is several multiples of traditional employment.

The data tells a brutal truth: gig economy income volatility is two to three times that of traditional employment, yet average income is roughly comparable. Workers are trading stability for so-called flexibility. More disturbing still, a significant proportion of gig economy days yield less than $50 — days when drivers sit in their cars burning fuel, waiting for dispatches that never come.

The data speaks:

Gig economy income volatility is 2-3x that of traditional employment. Average income is roughly the same.

This means: you are trading stability for flexibility.

But the question is: does the flexibility actually belong to you?

Who Controls the Rules?

In the Taylorist era, the rules were visible: the foreman told you the standard. The union could negotiate. Workers could strike.

In the Uber era, the rules are invisible: the algorithm is a black box. There is no union. Strike? The platform activates a new cohort of drivers.

The Algorithm’s Secret

We modeled the “black box” that drivers face — the platform tells them only that “rating: important,” “acceptance rate: important,” “cancellation rate: affects dispatch.” Vague descriptors with no quantitative content. What about peak-hour availability and completion rate? The platform responds with “?”

But the actual algorithm weights are precise: rating 0.35, acceptance rate 0.25, cancellation rate -0.20, peak-hour availability 0.15, completion rate 0.05. Drivers can never optimize their strategy because they do not know the complete list of variables, the weight of each variable, when the algorithm is updated, or whether any appeals process exists.

This is the essence of power:

Not who can control you, but the fact that you do not know how you are being controlled.

This is what Braverman would have recognized immediately. Taylor’s project was to expropriate craft knowledge from the worker. Uber’s project is to make the very concept of knowable rules obsolete. The worker is not merely deskilled — they are rendered epistemically helpless.

Conclusion: From Foreman to Algorithm, the Nature of Control Endures

Taylor and Uber, separated by 116 years, follow identical logic:

1. Decompose complex labor processes into quantifiable metrics
– Taylor: time, motion
– Uber: ratings, acceptance rates, GPS coordinates

2. Use mathematical models to optimize those metrics
– Taylor: stopwatch + industrial engineering
– Uber: machine learning + behavioral economics

3. Reduce worker autonomy
– Taylor: standardized processes
– Uber: algorithmic decision-making

4. Reduce supervision costs
– Taylor: fewer foremen per worker
– Uber: zero supervision cost

5. Maximize output
– Taylor: 200% productivity increase
– Uber: maximized driver hours on the road

The greatest difference:

Taylorism was honest exploitation — you knew you were being exploited.
Uber is invisible exploitation — you believe you are your own boss.

The final questions:

Which is worse? Is algorithmic governance more fair than human governance? Can we build “transparent algorithms”?

History provides a guide:

After the Industrial Revolution, workers spent a century fighting for their rights — the eight-hour day, the right to organize, workplace safety laws, social insurance.

After the digital revolution, how long will gig workers have to fight?

Taylorism created the labor movement.
What will Uber create?

The answer is in our hands.

Afterword: From the Stopwatch to the Algorithm

After finishing this article, I kept returning to the image of Taylor standing beside Schmidt in that Philadelphia steel mill.

It was 1899. The air smelled of coal smoke and molten iron. Taylor’s stopwatch ticked in his hand, recording every bend, every lift, every step. Schmidt could feel the gaze — the foreman was right there, physically present, undeniably real. You knew you were being watched. You knew the rules. You could even argue back. The control was naked, but at least it was honest.

One hundred and sixteen years later, an Uber driver sits in a parked car, staring at a notification on a phone screen: “Your acceptance rate is below the average for your area.” No one stands beside him. No stopwatch ticks. No one has told him what the “average” actually is. He faces an invisible system, a set of rules he can never fully decode. This form of control is more precise, cheaper to operate, and more unsettling — because you do not even know you are being controlled.

If you are a platform worker, the most important thing you can do may not be to complete a few more rides. It may be to start recording your own data. Calculate your true hourly wage — after deducting fuel, waiting time, vehicle depreciation. The number is often shockingly different from what the app displays. Those “just 3 more rides to hit your daily goal” notifications are not friendly reminders. They are precision-engineered behavioral nudges. Joining a workers’ collective or organization is not fighting against the platform — it is giving yourself a seat at the negotiating table in a game where the information asymmetry is overwhelming.

If you are an engineer, remember that behind every line of code you write are real human beings. Algorithmic ethics is not an academic slogan. When you set a threshold in a rating system, you are deciding who can feed their family and who cannot. Pushing for algorithmic transparency — explainable AI — is not merely a technical challenge. It is a moral obligation.

If you make policy, history offers a clear framework. After Taylorism, it took an entire century to build the protections we now take for granted: limits on working hours, minimum wages, workplace injury insurance. The EU’s Digital Services Act is a start, but digital-era labor rights still lag far behind the evolution of control technologies.

History does not repeat, but it rhymes.

A century ago, Taylor used a stopwatch to control workers. Today, platforms use algorithms to control workers. The form of control has changed. The substance has not. But this time, we have data, we have code, and we have the mirror of history. We have the opportunity to do better.

The prerequisite: we must see the power structures behind the algorithm.

Deep Dive: Complete Analysis Pack

This article shared the structural comparison between the Taylorist factory and Uber’s algorithm — from control mechanism simulation to income stability analysis, from information asymmetry quantification to algorithmic black box deconstruction. The complete analysis pack goes further:

• Full Taylorist factory simulation model: TayloristFactory class with fatigue curves and cost structure analysis; adjustable worker count, work hours, and supervision ratios to observe system behavior
• Uber algorithm simulation engine: UberAlgorithm class with surge pricing, rating-based filtering, income distribution; Lorenz curve and Gini coefficient for inequality quantification
• Six-dimensional radar chart comparison: monitoring density, autonomy, information symmetry, income stability, grievance channels, and exit costs — fully quantified
• Algorithmic black box decision tree visualization: transparent vs opaque power structures diagrammed, revealing the information gap drivers face
• ~420 lines of teaching-grade Python code, 14 advanced visualizations (300dpi PNG)

Get the Article 02 Deep Dive Pack ->

Next in the Series

1. Paris. Karl Marx wrote in his notebook: “The worker becomes poorer the more wealth he produces.” 180 years later, a food delivery rider stares at a phone screen: “Your rating has dropped to 4.5. Continued low ratings may affect your dispatch volume.”

Can Marx’s theory of alienation be quantified mathematically? How do alienation levels differ among artisans, factory workers, and gig workers? In the next article, we build an alienation index model and use NLP to trace the emotional trajectories of workers across two centuries — from Victorian factory diaries to modern social media posts.

References

• Taylor, Frederick Winslow. The Principles of Scientific Management. Harper & Brothers, 1911.
• Braverman, Harry. Labor and Monopoly Capital: The Degradation of Work in the Twentieth Century. Monthly Review Press, 1974.
• Rosenblat, Alex. Uberland: How Algorithms Are Rewriting the Rules of Work. University of California Press, 2018.
• Standing, Guy. The Precariat: The New Dangerous Class. Bloomsbury Academic, 2011.
• Scholz, Trebor. Platform Cooperativism: Challenging the Corporate Sharing Economy. Rosa Luxemburg Stiftung, 2016.
• Noble, David F. Forces of Production: A Social History of Industrial Automation. Knopf, 1984.
• Woodcock, Jamie. The Algorithmic Foodie: Labour and Platform Capitalism. Pluto Press, 2021.
• Kanigel, Robert. The One Best Way: Frederick Winslow Taylor and the Enigma of Efficiency. Viking, 1997.

Further reading: The evolution of Taylorist efficiency logic into modern management theory will be revisited from the perspective of capital efficiency in the forthcoming “Finance, Bubbles, and Crises” series.

About Code & Cogito

Decoding history through code. Understanding philosophy through data.

Newsletter — codecogito.com/subscribe
GitHub — Code-and-Cogito/code-cogito-public

Written by: Wina
Series: Industrial Revolution & Data Revolution #02/05
Tags: Taylorism, Algorithmic Management, Gig Economy, Labor Control, Platform Capitalism

(c) 2025 Code & Cogito. CC BY-NC-SA 4.0