Category: Software Development

  • Does AI Dominate All Programming Languages Equally?

    Does AI Dominate All Programming Languages Equally?

    No. AI performs far better in some languages (like JavaScript, Python, TypeScript) and far worse in others (like Rust, Haskell, COBOL, or highly specialized embedded languages).

    AI Dominates Best in “High-Surface-Area” Languages With Huge Training Data

    AI models perform best when a language:

    • has massive open-source code ecosystems
    • has lots of GitHub repositories (JS, TS, Python)
    • appears everywhere in tutorials, forums, StackOverflow, docs
    • is used in web development (simple, repetitive patterns ideal for LLMs)

    The biggest beneficiaries:

    • JavaScript / TypeScript
    • Python
    • SQL
    • HTML/CSS (small domain, predictable)

    These languages account for the majority of all public code on Earth, so AI models naturally excel at them. This is why AI coding demos overwhelmingly use JS, TS, or Python.

    JavaScript Case

    JavaScript is a dream for LLMs:

    • It’s ubiquitous
    • It’s forgiving
    • It has millions of nearly identical code examples
    • Prompts like “make a todo app” or “fetch this API” always produce workable patterns

    This is why Bun, Vercel, Cloudflare, Anthropic, OpenAI, and GitHub all showcase AI coding features using JavaScript/TypeScript.

    AI is Weaker in “Correct-by-Construction” or “Strict” Languages

    Languages built around correctness, strict typing, manual memory management, or advanced type systems are harder for AI to generate correctly.

    Examples where AI struggles more:

    Rust

    • Strong ownership and borrowing semantics
    • Compiler is strict
    • Memory safety rules are non-negotiable
    • Small ecosystem relative to JS

    AI can write Rust that looks right but fails to compile.

    Haskell / OCaml / F#

    • Strong functional paradigms
    • Less real-world training data
    • Abstract math-heavy patterns

    C and C++

    • Manual memory management
    • Project structure complexities
    • Undefined behavior hazards
    • Inconsistent patterns across codebases

    AI often generates code that segfaults or is not safe.

    Go

    • AI is moderately strong but weaker than in JS/Python because Go codebases are simpler but far fewer in number.

    AI Is Worst at Specialized or Legacy Languages

    Low-resource, domain-specific languages give available models very little to learn from:

    • COBOL (mainframes, banks)
    • ABAP (SAP)
    • VHDL/Verilog (hardware description languages)
    • MATLAB (scientific, proprietary)
    • LabVIEW
    • Embedded C dialects

    These domains:

    • Have minimal public code
    • Often include proprietary/internal code
    • Require deep domain knowledge beyond syntax

    AI frequently generates syntactically valid but practically unusable code.

    AI Performs Better at Glue Code Than Systems Code

    AI excels at:

    • CRUD
    • API wrappers
    • UI components
    • CLI tools
    • JSON transformations
    • Refactoring
    • Writing tests

    But struggles with:

    • Performance tuning
    • Concurrency
    • Systems-level code
    • Distributed systems
    • Memory-safety critical code
    • Security-sensitive code

    This is why AI produces React components with ease, but writing a correct multi-threaded C++ scheduler often fails.

    Model Architecture Matters

    Different AI models are better with different languages:

    Claude, ChatGPT, Cursor

    • Best at JS, TS, Python, SQL

    DeepSeek Coder (latest generation)

    • Stronger at C, C++, Rust, Go
    • Explicitly trained on low-level code
    • Still worse at JavaScript-scale “glue work,” but better at systems engineering tasks

    Copilot (OpenAI o-series & gpt-4o)

    • Extremely strong with TypeScript
    • GitHub training bias

    Tooling Influences AI Dominance

    Languages with strong AI-integrated dev tools:

    • JS/TS → Vercel AI, Copilot, Cursor
    • Python → Jupyter, PyCharm, GitHub Copilot
    • SQL → Natural language queries via AI

    Languages lacking good AI-native IDEs (COBOL, ABAP) remain AI-poor.

    Summary Chart

    LanguageAI StrengthReason
    JavaScript / TypeScript⭐⭐⭐⭐⭐Tons of training data, easy patterns, used everywhere
    Python⭐⭐⭐⭐⭐Hugely popular, simple syntax, ML + scripting
    SQL⭐⭐⭐⭐⭐Small domain, predictable patterns
    Go⭐⭐⭐⭐Moderate data, simple syntax
    Java⭐⭐⭐⭐Enterprise-heavy data, many repeatable patterns
    C#⭐⭐⭐Good ecosystem, less open-source surface
    C / C++⭐⭐Hard to reason, memory issues
    Rust⭐⭐Strict compiler rules
    Haskell / OCamlNiche, complex semantics
    COBOL, ABAP, HDLVery limited public training data

  • AI Is Reshaping What Engineering Work Looks Like

    The rapid rise of generative-AI in software development has sparked proclamations that AI will obsolete human programmers. But a closer look at major tech firms’ behavior — and recent research — paints a different picture. Rather than eliminating engineering jobs, AI seems to be reshaping what engineering work looks like — and in many cases increasing demand for engineers with the right skills to oversee, integrate, and scale AI-driven systems.

    Why the Narrative of “AI Will Kill Coding Jobs” Isn’t Holding Up

    It’s common to hear executives or media suggest AI will replace large swathes of software-engineering roles. Terms like “vibe coding” — where a developer prompts an AI and accepts its output — are gaining popularity as shorthand for an AI-first future. Wikipedia+1

    Yet firms continue hiring — and often hiring more. That suggests that even as AI becomes more capable, human engineers remain essential.

    Concrete Example: Anthropic + Bun Acquisition

    Take a recent, telling move: in December 2025, Anthropic acquired Bun — a JavaScript/TypeScript runtime and toolkit — at the same time it shared that its AI coding assistant (Claude Code) had reached a milestone of $1 billion in annualized run-rate revenue. IT Pro+1

    Bun is not a simple toy — it’s a foundational runtime used for building, bundling, and running JavaScript/TypeScript applications. By bringing Bun into its fold, Anthropic signaled confidence not just in AI-generated code, but in needing human engineers to build the infrastructure, integrate AI into real-world systems, and maintain stability and performance.

    In other words: even as Anthropic pushes forward with code-generating AI, it still invests in human engineering talent and software infrastructure. The acquisition underlines that AI alone isn’t sufficient — human oversight, toolchain maintenance, and architectural work remain essential.

    Broader Industry Pattern — Not Just One-Off

    This isn’t unique to Anthropic. Across the industry, there’s mounting evidence that AI adoption often correlates with continued, or even increased, hiring of engineers — especially those with expertise in AI, infrastructure, or integration. Analysts argue generative-AI doesn’t so much replace developers as it augments them — requiring new kinds of human skills. AP News+2Zen van Riel+2

    At the same time, studies of AI-generated code point to serious limitations: security flaws, lack of deep understanding of context, inefficient or sub-optimal patterns, and a need for human review. For example, one empirical study found that nearly 30 % of AI-generated Python snippets and 24 % of AI-generated JavaScript snippets showed security weaknesses when merged into real-world projects. arXiv

    These findings suggest that AI-generated code — while useful — remains far from “set it and forget it.” In many cases, human engineers must still review, debug, secure, and integrate the code, often adding complexity rather than removing it.

    Languages Matter — AI Doesn’t Dominate All Programming Languages Equally

    An important insight: AI’s effectiveness depends heavily on the programming language — and the nature of the task. Recent research into Large Language Model (LLM) preferences for code generation confirms that AI tends to favour certain languages. In one 2025 study, LLMs generated code in Python 90–97 % of the time for language-agnostic benchmark tasks, even when Python wasn’t the most suitable language for production code. arXiv

    That bias reflects both the abundance of training examples in languages like Python (and by extension, also languages like JavaScript or TypeScript) and the simplicity and flexibility of those languages. AI tools have a far easier time generating correct boilerplate, simple scripts, web-app code, and high-level logic in such languages. Zen van Riel+2IntuitionLabs+2

    On the other hand, languages that require stricter type systems, memory safety, or low-level control — such as Rust, C++, or languages used for systems programming — remain more challenging for AI. Some developers and community reports note that while AI can scaffold basic code in those languages, it often fails to satisfy compiler constraints, produce efficient or safe output, or handle complex system-level logic. BigGo+2AICodes+2

    Thus, AI’s impact is highly uneven: it’s more likely to disrupt or assist in web development, scripting, or high-level logic, while offering limited benefit in systems, embedded, or high-performance programming.

    What Remains the Role of Human Engineers — and What’s Changing

    Given these trends and limitations, here’s how the role of human engineers is evolving:

    • More emphasis on oversight, review, and integration: AI-generated code often needs human validation, security hardening, and testing. Engineers must review, debug, and refine output rather than simply accept it.
    • Higher demand for infrastructure, tooling, and system-level expertise: As firms build AI-assisted pipelines (like Anthropic integrating Bun), demand grows for engineers who can architect, maintain, and scale complex toolchains.
    • Shift toward languages and domains where AI is weaker: Systems programming, security-critical code, performance-sensitive components—areas where AI struggles—become more reliant on human expertise.
    • New hybrid workflows combining AI + human intelligence: Engineers increasingly act as supervisors, guides, and quality-assurance agents, using AI for boilerplate, scaffolding, or prototyping, while steering overall design.

    In many ways, AI is serving as a force multiplier — increasing what a given team can produce, but also increasing the need for thoughtful engineering, oversight, and human judgment.

    Why “AI Replaces All Engineers” Is Overstated — For Now

    Based on current evidence, the narrative that AI will wholesale eliminate software-engineering jobs seems overstated. Instead:

    • AI performs best on high-level, structured, well-documented languages — precisely where a large share of current web and app development lives.
    • AI-generated code is error-prone, insecure, or inefficient — making human review and expertise indispensable.
    • Companies adopting AI (like Anthropic) are also investing in building engineering teams — not downsizing them.

    Thus, the present and near-term future seem to favor more engineers — especially those capable of working with AI rather than being replaced by it.

    Conclusion — The Shape of Engineering Is Changing, Not Disappearing

    What we see in late 2025 is not the end of software engineering — but its transformation. AI doesn’t so much eliminate the need for human engineers as it shifts what kinds of engineering work matter:

    • From writing boilerplate or repetitive code
    • Toward system architecture, integration, maintenance, security, performance tuning, and high-level design
    • Toward languages and domains where AI assistance is less reliable

    In effect, AI becomes a toolchain multiplier, enabling faster development — but not eliminating the need for human engineers. If anything, demand for engineers adept at working in an AI-augmented world is rising.