Uber CEO: I Have To Be Honest, AI Will Replace 9.4 Million Jobs At Uber!

 

1. AI is the foundational engine for massive global platforms: Uber’s entire system is built on an AI core. Critical functions like pricing, routing, driver matching, and courier batching for 40 million daily trips are driven by small AI models that are trained on local problems and stitched together.

2. Intellectual jobs will be replaced faster than physical ones: AI is projected to have the capability to replace 70-80% of human intellectual work within the next 10 years. In contrast, physical AI (such as autonomous vehicles and robotics) will likely take 15 to 20 years because dealing with the physical world requires more capital and regulatory adjustments.

3. The unprecedented pace of AI will challenge societal adaptation: Unlike previous historical labor shifts (such as the move away from farming), the rapid 10-year timeline for AI disruption means society will have very little time to adjust and retrain the workforce, raising serious questions about mass unemployment.

4. AI is dramatically accelerating software engineering productivity: At Uber, 90% of coders are using AI tools. The 30% of engineers who are "power users" of AI are already showing a clear, distinct advantage in their productivity, measured by the number of code releases (diffs) they push.

5. The role of the software engineer will fundamentally change: Instead of manually writing code, the future job of a coder will largely involve orchestrating AI agents that write the code and build the systems for them.

6. Autonomous AI is already statistically safer than human drivers: Autonomous vehicles (like Waymo and self-driving Teslas) currently get into fewer accidents than human drivers. Furthermore, an autonomous agent paired with a human backup is definitively safer than a human driving alone.

7. Millions of physical driving jobs will eventually be automated: Within the next 15 to 20 years, it is expected that the 9.4 million driving and courier jobs currently on platforms like Uber will be replaced by autonomous vehicles and robots.

8. Current AI lacks the ability to learn in real-time: A key limitation of current AI models is that they cannot learn continuously during a live interaction. While humans can change their behavior instantly based on what they learn in a conversation, AI relies on pre-training and delayed post-training updates.

9. AI job displacement threatens human meaning and purpose: As AI takes over intelligence and physical labor, society faces a crisis of purpose. Studies on universal basic income show that simply giving people money does not replace the deep sense of self-worth, value, and meaning that individuals gain from working and providing for their families.

10. Employees are using AI to simulate their CEOs: In a creative use of the technology, some corporate teams are building AI versions of their executives (such as a "Dara AI") to practice and fine-tune their slide decks and presentations before pitching to real leadership

Vibe Coding: What It Is and Why Everyone’s Talking About It

 

What is Vibe Coding?

 The phrase “vibe coding” took off in early 2025 after Andrej Karpathy’s “see stuff, say stuff, run stuff, copy-paste stuff” description of AI-first building. It reframed coding as a creative, conversational flow, not a grind. You state the intent, the constraints, and the user experience. AI agents stitch together scaffolding, libraries, and glue. You stop memorizing stacks, start describing goals, and the system returns queries, UI, and wiring.

The loop is conversational. It shines for prototypes and internal tools, and it can supercharge senior engineers. The catch: you still own acceptance criteria, data handling, and performance budgets. Put tests, linting, and basic security in place. \

Why Now

Engineering capacity is tight, costs are up, and backlogs are the norm. Leaders still need new products, internal systems, and experiments. Hiring alone won’t close the gap. The interface to build had to change.

AI bridged it. Autocomplete turned into function generation, then feature stubs, and now agents that draft entire apps with minimal supervision. That evolution:

• Collapses time to value from weeks to hours.
• Shifts effort from syntax to outcomes, UX, and guardrails.
• Unlocks the long tail of “would never get staffed” ideas.

Crucially, it fits today’s risk climate. Iterate in small loops. Test fast. Only harden what proves traction. With talent scarcity, AI maturity, and budget pressure aligning, vibe coding is becoming the default path to ship software.

What You Gain

• Developer leverage
  AI takes scaffolding, boilerplate, and glue work off the table. Engineers focus on architecture, performance, and security. Senior devs review and refine rather than hand-type every line.
• Rapid prototyping
  Idea to MVP happens in hours, not weeks. You validate problem-solution fit with real users sooner, cut detours, and generate evidence your stakeholders trust.
• Wider access to building
  Non-developers can ship by describing outcomes in plain language. Entrepreneurs, designers, and domain experts can prototype, test, and iterate without living in a framework.
• Conversational iteration
  The rhythm is describe-run-refine. Small, reversible diffs keep progress steady and auditable, encouraging exploration without chaos.
• Innovation velocity
  Lower effort per attempt means more shots on goal across features, UX variants, and pricing experiments. Faster loops surface what actually moves revenue, retention, and utilization.
• Cost and risk reduction
  Automated scaffolding and shorter cycles cut delivery costs and speed time to value. Versioned checkpoints, tests, and minimal patches curb rework and incident risk. You only harden what proves out.

How Vibe Coding Actually Works

 Vibe coding runs like a tight teammate brief to ship loop: start by describing what the product does, who will use it, and what “done” means. Then let the AI produce a runnable first cut so you hit working state fast rather than perfect. Move in tight feedback loops - run it, surface what broke, and ask for targeted fixes - while putting rails on the process with tests, linting, types, and checks so “works once” becomes “works reliably.” Once the concept clicks, refactor for structure and readability, and leave a clear trail by documenting decisions so others can reproduce or audit. Finally, ship with safeguards - monitoring, security, reviews, and user protections - to make the step from prototype to production safe and predictable.

Prompting and Process Tips

• Keep prompts atomic: one change, explicit inputs/outputs, performance and security bounds.
• Share just enough context: exact files, schemas, logs; expand only as needed.
• Checkpoint every loop: commit AI diffs with a one‑liner on why.
• Block merges on failing tests, lint errors, and type gaps.
• Patch minimally: preserve public APIs and contracts.
• Ask for tradeoffs and alternatives, plus what changed and where.
• Freeze interfaces (DTOs, events, endpoints) so internals can evolve safely.
• Set guardrails early: auth, validation, dependency policy, rate limits, logging.

Bottom Line

Vibe coding is outcome-directed software creation. You describe the product in plain language and let AI generate and refine the code within clear guardrails. It’s ideal for prototypes, internal tools, and amplifying experienced devs. The risks are manageable with tests-first, explicit constraints, interface freezes, and security checks. Done right, vibe coding expands who can build, increases shots on goal, and keeps quality in bounds while shrinking the distance from idea to working software.

The Rise of Vibe Coding

 

Vibe Coding: What It Means and Why It’s Everywhere

 Vibe coding is a new way of building software where you spend less time writing syntax and more time steering outcomes. Instead of manually assembling frameworks, wiring APIs, and stitching UI components together, you describe what you want the product to do and an AI agent generates the working code.

Think of it as shifting from “coder” to “director.” You define intent, constraints, and what success looks like. The AI handles the scaffolding, boilerplate, and glue work that usually slows teams down. At its best, vibe coding turns an idea into something runnable in one sitting, then improves it through a fast, conversational loop.

The Core Idea

Traditional development often starts with choosing a stack, setting up folders, configuring dependencies, and slowly layering in features. Vibe coding flips that sequence.

You start with a goal like:

• build a cross-platform dashboard
• connect scheduled posting
• track engagement by channel
• export reports weekly

Then the agent generates the UI, data queries, and application wiring, often in a single pass. From there, your job becomes guiding the build with precise feedback: what works, what’s wrong, what needs refactoring, and what constraints must never be violated.

The Vibe Coding Loop in Practice

Vibe coding works best when you treat it like iterative product development, not magic. A common workflow looks like this:

1. Brief the AI like a teammate: who it’s for, what it does, what success looks like.
2. Get something runnable quickly: speed matters more than perfection early on.
3. Run it and capture friction: errors, weird behaviors, missing edge cases.
4. Ask for targeted fixes: small diffs, minimal patches, preserved contracts.
5. Add rails early: tests, linting, types, validation, so quality stays visible.
6. Refactor after it proves value: structure and readability once the shape is right.
7. Harden only when shipping: monitoring, auth, security reviews, rollback plans.

The Benefits, Broken Down

1. More People Can Build

Domain experts, founders, and designers can express intent directly without deep framework knowledge. That expands who can prototype and validate ideas.

2. Faster Prototypes, Faster Decisions

When MVP cycles shrink from weeks to hours, teams learn earlier what to keep, what to drop, and what users actually want.

3. Higher Leverage for Developers

Engineers spend less time on scaffolding and glue code, and more on architecture, performance, security, and systems thinking.

4. Tight Iteration Becomes the Default

Describe → run → refine becomes a natural rhythm. Done well, it stays auditable because changes are incremental and reversible.

5. Better Governance (When You Add Rails)

With tests, CI, contracts, and versioned prompts, quality becomes measurable instead of “it seems fine.”

6. More Shots on Goal

Lower effort per attempt means more experiments in UX, features, and workflows without ballooning cost.

7. Lower Cost and Lower Waste

You don’t over-invest early. You harden the parts that earn traction, and cut the rest before it becomes expensive.

The Risks (and How to Counter Them)

Vibe coding isn’t a substitute for engineering judgment. It’s a speed amplifier and that means mistakes can scale too.

“Working” isn’t production-ready

Early outputs can contain inefficiencies, leaky abstractions, and inconsistent structure.
Fix: plan a refactor stage; request migration-safe changes and rollback steps.

Debugging can get murky

Without documentation, it’s hard to extend or trace failures.
Fix: demand rationales for non-trivial decisions and keep a changelog/prompt contract.

Technical complexity gets glossed over

Agents may choose simple patterns that don’t handle concurrency, real-time constraints, or large data volumes.
Fix: specify SLAs, expected volumes, and latency targets up front; add load tests and profiling early.

Maintenance debt can explode

Fast iterations can produce duplicated logic and hidden coupling.
Fix: schedule stabilization passes and enforce architecture rules in CI.

Teams can become overly dependent

If no one understands the generated system, incidents and handoffs get painful.
Fix: keep humans owning critical paths (auth, billing, migrations, PII) and require short human-written “owner’s manuals.”

Prompt quality sets the ceiling

Vague requests produce fragile systems.
Fix: include versions, data shapes, error rules, and strict “no failing checks on main” discipline.

Niche logic still needs expertise

Highly specific domain rules or precision systems often require bespoke work.
Fix: provide domain examples, acceptance tests, forbidden choices, and golden datasets.

Bottom Line

Vibe coding is building software by describing outcomes in plain language while AI generates and refines the implementation. It shifts effort away from syntax and toward intent, UX, constraints, and quality rails, compressing idea-to-prototype time dramatically. It’s not a replacement for engineering judgment. You still own acceptance criteria, data handling, performance tradeoffs, and security. But used with discipline - tests-first workflows, clear interfaces, and tight iteration loops - it becomes a force multiplier. Done right, vibe coding helps teams move from “we should build this someday” to “we have a working version now,” without surrendering control.

The New Way to Code: Claude Code

 

What is Claude Code and What It Actually Does

 Claude Code is Anthropic’s agentic coding assistant built to operate where many developers already work: the command line. Instead of acting like a snippet generator, it behaves more like a collaborator that can navigate your repository, read and edit files, and execute tasks you approve - directly from the terminal (with options to use it in IDEs and on the web as well).

Claude Code doesn’t just answer questions about code. It can take action inside your project environment. That means it can move through folders, open files, propose edits, and coordinate multi-step changes across a codebase - similar to how you’d do it manually, but guided by natural language.

A key difference is that it’s designed to understand repositories as systems, not as isolated snippets. After an initial scan, it can reason about structure, dependencies, and conventions without you constantly pasting context into the chat. It also comes ready to work without requiring additional tool setup. You can extend it later with more integrations, but you can start doing meaningful work immediately.

Why Developers Reach for Claude Code

Many assistants can generate code. Claude Code is focused on getting real work done inside a real repo with guardrails and workflow support that match how teams ship software.

Here’s what tends to stand out:

• Repository-level understanding: It quickly maps how the project is organized and how files relate, which helps it refactor or debug across modules instead of guessing.
• Safer autonomy: It starts in a cautious mode (often read-only) and requests permission before editing files, running commands, or triggering tests.
• Multi-file edits that stay coherent: Useful when changes require updating types, imports, config, tests, and documentation together.
• Terminal-first productivity: You can stay in the CLI for edits, verification, and git workflows rather than bouncing between tools.
• Quality loops built in: It can run linters/tests, interpret failures, apply fixes, and retry until your checks pass—under your control.

What You Can Use It For Day-to-Day

 Claude Code is most valuable when tasks involve more than a single function or file. For example:

• Debugging issues that require tracing behavior across folders
• Refactoring features while keeping public interfaces stable
• Writing or improving test coverage around existing code
• Reorganizing utilities, shared helpers, and business logic cleanly
• Running formatting, linting, and quick verification cycles
• Managing branches, commits, and resolving merge conflicts

In short: it fits best when the work is multi-step and context-heavy.

Who Benefits Most From Claude Code?

Claude Code is a strong fit for teams and individuals who spend their time in production codebases. Software developers often use it to improve maintainability, reduce repetitive edits, and execute safer refactors with reviewable diffs. Open-source contributors benefit from faster onboarding to unfamiliar repositories. Instead of reading the entire project manually, they can ask the assistant to map the structure, explain where logic lives, and help produce clean PRs with tests. DevOps and platform engineers use it to streamline routine workflows - running checks, keeping branches tidy, and reducing “pipeline red” moments by iterating locally with fast feedback.

Best Practices for Getting Reliable Results

Start with clear direction

Claude performs best when you provide:

• the goal: what “success” looks like
• constraints: APIs to preserve, performance limits, style rules
• what must not change
• a short definition of done

Keep work sessions narrow

Avoid mixing multiple unrelated goals in one long session. When you switch tasks, reset context, then restate the objective and constraints, and keep a short status note inside the repo for continuity.

Ask for a plan first

Before major changes, request a quick outline:

• what it will inspect
• which files it expects to modify
• how it will verify correctness (tests, lint, type checks)

This gives you a cheap opportunity to redirect before edits begin.

Verify early and frequently

Treat validation as part of the workflow - run quick tests and linters after meaningful changes. When failures happen, have Claude explain the cause, fix it, and re-run checks

Use permissions deliberately

Approvals are part of the safety model. Allowlist routine commands, but keep anything risky gated. If something looks odd, ask why it’s needed before approving.

Final Takeaway

Claude Code is best thought of as a terminal-first engineering partner: it translates plain-language intent into repo-aware execution. It can explore your codebase, propose an approach, apply coordinated changes across files, and run the same verification and git steps you’d perform manually.

It shines most on work that’s easy to derail when done by hand - multi-file refactors, debugging across modules, and iterative quality loops. Treat it like a highly capable junior engineer: give crisp requirements, keep tasks scoped, review diffs, and let tests decide. Used that way, it can speed up reliable shipping without pulling you out of your terminal workflow.

What's Claude Code

Claude Code is Anthropic’s agentic coding assistant built to live where developers actually work - the terminal. It understands your repository, navigates files and folders, proposes a plan, and executes changes in small, reviewable steps. You can also use it inside IDEs and the web, but the terminal is where it shines.

Think of it as a disciplined co-developer that reads your project, explains what it’s about to do, and follows through with clean diffs and safe git operations. Minimal setup. No hand-feeding huge prompts. Real work gets done.

How It Operates

Claude Code scans your codebase to map structure and dependencies. From there, it can read and edit files, create or reorganize modules, and run commands - all triggered by natural language. It keeps you in control by asking for permission before edits, tests, or commands. Out of the box, it supports exploration, safe edits, and git workflows. You can add MCPs for more power later, but you don’t need them to get value on day one.

What It’s Built To Do

• Deep project awareness - Quickly learns file layout and dependencies so it can reason across modules instead of guessing from a single snippet.
• Safe-by-default execution - Read-only start; prompts for approval before edits or commands. Supports allowlists and sandboxing for safer autonomy.
• Smart file operations - Creates, splits, and reorganizes files with intent. Keeps utilities separate from business logic to maintain clarity.
• End-to-end loops - Debug, refactor, write tests, and verify - all without leaving the terminal.
• Reliable git hygiene - Manages branches, restores lost files, writes clean commits, and helps resolve conflicts. Undo mistakes fast.
• Natural language to working code - Ask for fixes or improvements in plain English. Review a to-do plan and approve step by step.
• Integrated quality loop - Runs tests and linters, explains failures, proposes fixes, and iterates to green.
• Flexible setup - Useful immediately without MCPs; extensible when you need more.
• Scales with your repo - Handles small OSS projects and large monorepos, adapting to your conventions.

Who Benefits Most

 Claude Code is built for teams working in real codebases, not demos. Software engineers use it to lift code quality quickly, refactor safely, and keep architectural boundaries clean without the manual grunt work. Open source contributors rely on its deep repo understanding to navigate unfamiliar projects, propose focused changes, and ship tight PRs with solid tests. DevOps and platform engineers lean on it to automate linting, test runs, and branch hygiene so pipelines stay green and rollbacks stay rare. If your day involves reading across files, tracing edge cases, and keeping commits tight, Claude Code acts like a disciplined junior engineer with good habits and a clear paper trail.

Limitations To Expect - And How To Mitigate

Context drift in long sessions

Symptom: After extended back-and-forth, details can drop during auto-compaction.

Mitigation: Repost acceptance criteria, key interfaces, and constraints from TASKS.md or a spec file.

Terminal learning curve

Symptom: Power is there, but it’s not point-and-click.

Mitigation: Use the VS Code extension if you prefer an editor-first workflow.

Occasional over-editing or suboptimal paths

Symptom: Like any agentic tool, it may touch more than needed or miss a cleaner route.

Mitigation: Keep feature branches small, review diffs, and rely on tests/linters to catch regressions early.

Best Practices

Ask for a plan first

For anything beyond a tiny fix, have it outline what it will inspect, files it expects to touch, and how it will verify. Cheapest place to course-correct.

Be specific upfront

Share constraints that matter: public APIs/contracts, backward compatibility, performance budgets, coding style, “must not change” areas. Add a clear definition of done.

Keep sessions scoped

Long, multi-topic chats increase drift. When switching work, reset context with your objective and constraints. Keep a short status log in-repo for continuity.

Anchor requirements in the repo

Store persistent rules in CLAUDE.md (workflow, style, preferred commands) and put milestones/acceptance criteria in TASKS.md or a spec. Treat those as the contract.

Control compaction

If the chat compacts or feels fuzzy, restate acceptance criteria, API invariants, and migration constraints. Use compaction with a focus on what to preserve.

Verify early and often

Run unit tests, type checks, and linters after each meaningful edit. When something fails, have Claude explain, propose a fix, and rerun until green.

Use permissions intentionally

Treat approvals like code review. Allowlist safe commands (tests, formatters, status) and keep risky operations gated. Ask “what and why” for unusual commands.

Bottom Line

Claude Code is best viewed as a terminal-first teammate that turns plain-language intent into coordinated, verifiable execution. It reads your repo, proposes a plan, makes targeted edits, and runs the same tests and git steps you would. The agentic loop pays off on multi-file, multi-step tasks where momentum and precision matter. Set clear criteria, keep sessions scoped, review diffs, and let tests be the judge. Do that, and you’ll ship reliable changes faster - without leaving the terminal.

Privacy Policy

Privacy Policy

Who we are

Our website address is: https://www.aivibeclub.org/

AI VIBE CLUB is a non-profit organisation that supports the growth of entrepreneurship and innovation by popularising, implementing and ethically using artificial intelligence technologies in business processes.

What personal data we collect and why

Comments

When visitors leave comments on the site, we collect the data shown in the comments form, as well as the visitor's IP address and user agent string to help detect spam.

Media files

When uploading images to the website, avoid uploading images with embedded location data (EXIF GPS). Visitors to the website can download and extract any location data from images on the website.

Cookies

If you leave a comment on our site, you can choose to save your name, email address, and website in cookies. This is for your convenience so that you do not have to fill in your details again when you leave another comment. These cookies will last for one year.

If you have an account on this site and you log in, we will set a temporary cookie to determine if your browser supports cookies. This cookie contains no personal data and is discarded when you close your browser.

When you log in, we also set up several cookies to save your login information and screen display choices. Login cookies are stored for two days, and screen settings cookies are stored for one year.

Embedded content from other websites

Articles on this site may contain embedded content (e.g., videos, images, articles, etc.). Embedded content from other sites behaves in the same way as if the user visited the other site.

These websites may collect data about you, use cookies, embed additional third-party tracking, and monitor your interaction with that embedded content, including tracking your interaction with the embedded content if you have an account and are logged in to that website.

Who we share your data with

We do not sell, trade, or transfer your personal data to third parties without your consent, except as required by law.

How long we retain your data

If you leave a comment, the comment and its metadata are retained indefinitely. This is so we can recognise and approve any follow-up comments automatically instead of holding them in a moderation queue.

For users who register on our website, we also store the personal information they provide in their profiles. All users can view, edit, or delete their personal data at any time (except for their username, which they cannot change). Website administrators can also view and edit this information.

What rights you have over your data

If you have an account on this site or have left comments, you can request to receive an exported file of the personal data we hold about you, including any data you have provided to us. You can also request that we erase any personal data we hold about you. This does not include any data we are obliged to keep for administrative, legal, or security purposes.

Where we send your data

Visitor comments may be checked through an automated spam detection service.

How we protect your data

We use appropriate technical and organisational measures to protect your personal data from unauthorized access, use, disclosure, alteration, or destruction.

Changes to this privacy policy

We may update our privacy policy from time to time. We recommend that you review this page periodically for the latest information on our privacy practices.

Contact Information

If you have any questions about this privacy policy, please contact us:

d@aivibeclub.org  or by phone at +380503080520