Code Olympics 2025: 66 Teams Proved You Don’t Need npm to Build Real Software

The average React project downloads 350MB of dependencies before writing a single line of business logic. Modern web applications ship with 1,200+ npm packages to accomplish tasks that require perhaps 50 kilobytes of actual code. When Code Olympics 2025 stripped away these safety nets—forcing 66 teams to build functional applications using only built-in functions, maximum 8 variables, or under 200 lines of code—the results challenged comfortable assumptions about what constitutes “realistic” programming.

Over 72 hours from October 31 to November 3, 2025, participants confronted randomly assigned constraints that eliminated the tools modern development provides: No external libraries. Single-function implementations. Line budgets that forced every statement to justify its existence. The 230+ judge evaluations revealed consistent patterns in how developers adapt when familiar abstractions disappear—and why those abstractions may be hiding fundamental weaknesses.

The Developer Experience Paradox

Modern development prioritizes speed through abstraction. Frameworks handle complexity automatically. Libraries solve problems developers never see. Build tools manage dependencies invisibly. This optimization for immediate productivity creates what Artem Mukhin, Software Engineer at Microsoft and Code Olympics judge, describes as a critical tension in his own work.

“At Microsoft, I’ve spent years optimizing developer experience—reducing build times from 60+ seconds to 2-5 seconds, improving fast refresh, making tools that help developers work faster,” Mukhin explained during evaluation. However, there’s a distinction between tools that deepen understanding and those that merely replace it. When build times are slow, you learn patience and write more deliberate code. When they’re instant, you might never develop that discipline.”

Mukhin’s background provides unique perspective on this paradox. His seven years at Yandex included designing and implementing two React/TypeScript applications simultaneously as the only frontend developer—in three months under tight deadlines. “Those constraints forced deep understanding,” he noted. “When you can’t add another dependency or bring in another developer, you learn to solve problems with what you have.”

His trajectory from graphic designer to analytics software engineer to frontend developer reveals someone who repeatedly chose constraint-driven learning. “I was afraid to make phone calls when I started as a designer,” he recalled. “But I gained loyal customers because I understood their needs. That pattern repeated in each transition—facing limitations, developing genuine understanding, then moving to where that understanding created value.”

The Three-Dimensional Constraint System

Code Olympics implemented a generation system producing 640 unique challenges from three independent dimensions, ensuring no two competitors faced identical constraints:

Core Constraints (8 options including):

• No-Import Rookie: Only built-in functions, zero external libraries
• Few-Variable Hero: Maximum 8 variables across entire program
• Single-Function Master: Only 1 function allowed (plus main)
• Error-Proof Coder: Program never crashes, handles all inputs gracefully
• One-Loop Warrior: Maximum 1 loop in entire program

Line Budgets (8 tiers):

• Tiny Scripter (50 lines) → Mini Builder (100) → Compact Coder (150) → Standard Maker (200) → Detailed Creator (300) → Feature-Rich Dev (400) → Professional Builder (500) → Enterprise Creator (650)

Project Domains (10 categories):

• Simple Games, Basic Tools, Text Processing, Number Crunching, File Management, Quiz Systems, Visual Creation, Mini Databases, Web Scrapers, System Utilities

Participants received combinations like “No-Import Rookie + 200 lines + System Utilities” with three re-roll opportunities. This randomization prevented clustering around popular constraints while maintaining measurable difficulty distribution.

First Place: When Terminal Becomes Canvas

CuteBunny’s Vist (Visual Terminal Tool) – Score: 4.480/5.00 | Prize: $1,100

The grand champion transformed a text-only terminal into a multimodal visualization environment supporting four distinct operational modes: ASCII art image rendering, structured data visualization, interactive terminal games, and video playback with audio synchronization.

The technical achievement wasn’t feature breadth—it was reliability across all modes despite severe constraint limitations. Vist’s architecture demonstrated production-grade thinking:

Adaptive Resource Management:

python

def detect_capabilities():

    “””Detect GPU/CPU capabilities and adapt rendering strategy”””

    gpu_available = check_vulkan_opencl_support()

    if gpu_available:

        renderer = GPUAcceleratedRenderer(target_fps=35)

    else:

        renderer = CPUFallbackRenderer(target_fps=20)

    # Dynamic terminal size adaptation

    term_size = os.get_terminal_size()

    renderer.set_viewport(term_size.columns, term_size.lines)

    return renderer

The game mode maintained smooth 35 FPS through careful frame timing without game engine dependencies. Video mode achieved audio-video synchronization using only Python’s standard library threading and time modules. The ASCII art renderer adapted character density based on terminal color capabilities.

“This could evolve into a cross-platform multimedia framework,” judge Naman Jain noted. The architecture shows a solid grasp of building resilient, resource-aware systems—exactly what embedded developers do, only applied to terminal interfaces.

Mukhin’s evaluation focused on the development experience implications: “What impressed me was how Vist handles degradation. When GPU isn’t available, it doesn’t crash—it adapts. When terminal size chCalC shows the same discipline.”anges, it recalculates. That’s the kind of defensive programming you develop when you can’t rely on frameworks to catch your mistakes.”

The Constraint Mastery Winner: Zero Dependencies, Maximum Features

CalC’s Omni_convertor – Score: 4.88/5.00 | Prize: $100

CalC achieved the highest constraint mastery score by building a comprehensive conversion toolkit using exclusively Python’s built-in functions—no imports allowed. The system handled unit conversions (temperature, length, weight, volume), number base conversions (binary, octal, decimal, hexadecimal), and remarkably, Morse code translation.

python

# Morse code conversion without imports

MORSE = {

    ‘A’: ‘.-‘, ‘B’: ‘-…’, ‘C’: ‘-.-.’, ‘D’: ‘-..’, ‘E’: ‘.’, 

    ‘F’: ‘..-.’, ‘G’: ‘–.’, ‘H’: ‘….’, ‘I’: ‘..’, ‘J’: ‘.—‘,

    # … complete mapping

}

def text_to_morse(text):

    “””Convert text to Morse using only dict lookups and str methods”””

    result = []

    for char in text.upper():

        if char in MORSE:

            result.append(MORSE[char])

        elif char == ‘ ‘:

            result.append(‘/’)

    return ‘ ‘.join(result)

Judge Roman Kamyshnikov’s assessment captured the achievement: “This is done in the spirit of the hackathon—well written, a breeze to read. The morse converter is amazing.” The code demonstrated that constraints don’t necessarily reduce functionality—they force efficiency.

The project’s architecture revealed patterns Mukhin recognized from his own constraint-driven work: “At Yandex, I automated presentation creation with Python integrated with Excel and PowerPoint, greatly improving team productivity. That required similar thinking—working within Microsoft Office’s constraints to deliver real utility. CalC shows the same discipline.”

Developer Experience Insights from Constraint Programming

The evaluation process revealed how constraint programming surfaces capabilities that framework-heavy development often masks. Mukhin drew connections to his role optimizing developer workflows at Microsoft:

“When I improved build times from 60 seconds to 2-5 seconds, developers became more experimental—they’d try things, see results instantly, iterate rapidly. That’s valuable. But Code Olympics participants couldn’t iterate that way. They had to think before coding, plan architecture carefully, understand exactly what their code would do.”

This distinction matters for skill development. Mukhin’s career progression involved repeatedly removing safety nets: moving from analytics to frontend development meant leaving SQL and VBA for React and TypeScript. “Early in my career, I could query a database to understand code behavior. Moving to frontend, I had to understand JavaScript execution models, browser APIs, state management patterns. The constraints forced deeper learning.”

The Variable Economy Challenge

The Few-Variable Hero constraint (maximum 8 variables) revealed particularly stark differences in developer approaches. Successful teams developed sophisticated state management within severe restrictions:

python

# Managing game state with 8 variables maximum

def tic_tac_toe():

    b = [‘ ‘]*9  # board (1 var)

    p = ‘X’      # player (2)

    m = 0        # moves (3)

    w = None     # winner (4)

    while m < 9 and not w:

        # Input, validation, move execution, win check

        # All logic reuses these 4 variables

        i = int(input(f”Player {p}, position (1-9): “)) – 1

        if b[i] == ‘ ‘:

            b[i] = p

            m += 1

            # Win check logic here

            p = ‘O’ if p == ‘X’ else ‘X’

“This constraint forces the kind of thinking you need in resource-constrained environments,” Mukhin observed. “When I optimized React applications at Yandex, removing unnecessary state updates and calculations improved performance dramatically. Variable restrictions teach that discipline by making waste impossible.”

Second and Third Place: Production-Grade Thinking Under Constraints

3s’s Code Auditor – Score: 4.420/5.00 | Prize: $300

The second-place winner built a professional-grade security scanner that runs in under 3 seconds—analyzing code for secrets, API keys, SQL injection patterns, and security vulnerabilities using pure Python without external dependencies.

The tool’s architecture demonstrated understanding of how security scanners actually work:

python

def scan_file_for_secrets(filepath, patterns):

    “””Fast pattern matching without regex libraries”””

    with open(filepath, ‘r’, encoding=’utf-8′, errors=’ignore’) as f:

        content = f.read()

    findings = []

    for pattern_name, pattern_indicators in patterns.items():

        for indicator in pattern_indicators:

            if indicator.lower() in content.lower():

                # Extract context around match

                idx = content.lower().find(indicator.lower())

                context = content[max(0, idx-40):idx+40]

                findings.append({

                    ‘type’: pattern_name,

                    ‘file’: filepath,

                    ‘context’: context

                })

    return findings

Judge Naman Jain noted: “Impressive work, shows deep security knowledge and solid engineering.” The depth of security checks—from AWS keys to private key detection—demonstrated patterns only someone who understands vulnerabilities could implement.

PILYT’s YouTube Knowledge Library – Score: 4.420/5.00 | Prize: $200

Third place converted YouTube videos into searchable JSON knowledge bases with offline subtitle parsing, summary generation, and cross-platform playback integration—all without video processing libraries.

The system’s subtitle parser handled various caption formats using only Python’s standard library:

python

def parse_vtt_subtitles(subtitle_file):

    “””Parse WebVTT format without external dependencies”””

    with open(subtitle_file, ‘r’, encoding=’utf-8′) as f:

        content = f.read()

    entries = []

    current_text = []

    for line in content.split(‘\\n’):

        line = line.strip()

        if ‘–>’ in line:  # Timestamp line

            continue

        elif line and not line.startswith(‘WEBVTT’):

            current_text.append(line)

        elif not line and current_text:  # Empty line ends entry

            entries.append(‘ ‘.join(current_text))

            current_text = []

    return entries

Judge Kishore Subramanya Hebbar observed: “PILYT shows recursive design patterns and excellent craftsmanship.” The project demonstrated how understanding file formats enables building tools without heavy dependencies.

What 66 Teams Revealed About Developer Fundamentals

The competition results surfaced consistent patterns across constraint categories. Teams with strong fundamentals adapted quickly; those relying heavily on framework knowledge struggled visibly.

The No-Import Shock

The No-Import Rookie constraint (built-in functions only, zero libraries) proved most revelatory. Approximately 40% of initial submissions attempted imports before constraint validation caught them—suggesting reflexive dependency reaching had become unconscious.

Successful No-Import projects demonstrated:

• Algorithm implementation from first principles: Sorting, searching, and data structure operations without library functions
• Format parsing without regex libraries: CSV, JSON, and subtitle parsing using string methods
• State management without frameworks: Complex application state using only dictionaries and lists

Mukhin connected this to his own experience: “When I moved from analytics to frontend, I had to build my first React application in three months with zero external help. That constraint taught me React deeply—not just how to use it, but how it actually works. No-Import participants are getting that same forcing function.”

The Line Budget Reality Check

Line limitations revealed code organization skills. Projects under 200 lines required every function to justify existence. The Compact Coder tier (150 lines) showed particularly stark differences:

python

# Inefficient approach (uses 20+ lines)

def calculate_temperature_conversion(value, from_unit, to_unit):

    if from_unit == ‘celsius’:

        if to_unit == ‘fahrenheit’:

            return (value * 9/5) + 32

        elif to_unit == ‘kelvin’:

            return value + 273.15

    elif from_unit == ‘fahrenheit’:

        if to_unit == ‘celsius’:

            return (value – 32) * 5/9

        elif to_unit == ‘kelvin’:

            return (value – 32) * 5/9 + 273.15

    # … continues for all combinations

# Efficient approach (uses 7 lines)

CONVERSIONS = {

    (‘celsius’, ‘fahrenheit’): lambda x: x * 9/5 + 32,

    (‘celsius’, ‘kelvin’): lambda x: x + 273.15,

    (‘fahrenheit’, ‘celsius’): lambda x: (x – 32) * 5/9,

    # … all combinations as lambda functions

}

def convert_temperature(value, from_unit, to_unit):

    return CONVERSIONS.get((from_unit, to_unit), lambda x: x)(value)

“This pattern appears constantly in performance optimization,” Mukhin noted. “When I cut page load times by 30% at Yandex, much of the improvement came from eliminating unnecessary code—rendering optimizations, removing duplicate calculations. Line constraints teach that mindset by making bloat impossible to hide.”

The Error-Proof Challenge: Defensive Programming Under Pressure

The Error-Proof Coder constraint (program never crashes, handles all inputs gracefully) separated developers who understood error handling from those who relied on framework safety nets.

Winning error-proof projects implemented:

• Input validation without validation libraries
• Graceful degradation when resources unavailable
• Comprehensive exception handling without try-except proliferation

python

def safe_division_calculator():

    “””Error-proof calculator without external validation”””

    while True:

        try:

            a = input(“First number (or ‘quit’): “)

            if a.lower() == ‘quit’:

                break

            # Validate numeric input manually

            if not all(c in ‘0123456789.-‘ for c in a):

                print(“Invalid number format”)

                continue

            b = input(“Second number: “)

            if not all(c in ‘0123456789.-‘ for c in b):

                print(“Invalid number format”)

                continue

            op = input(“Operation (+, -, *, /): “)

            if op not in [‘+’, ‘-‘, ‘*’, ‘/’]:

                print(“Invalid operation”)

                continue

            a, b = float(a), float(b)

            if op == ‘/’ and b == 0:

                print(“Cannot divide by zero”)

                continue

            result = {

                ‘+’: a + b,

                ‘-‘: a – b,

                ‘*’: a * b,

                ‘/’: a / b

            }[op]

            print(f”Result: {result}”)

        except ValueError:

            print(“Invalid input format”)

        except KeyboardInterrupt:

            print(“\\nExiting…”)

            break

“This is exactly the defensive programming you need in production,” Mukhin observed. At Yandex, I contributed to shared React component libraries used throughout the department.
Every component had to handle edge cases because we couldn’t predict every use case. Error-Proof constraints teach that same paranoia.”

The Dependency Data Behind the Constraints

The challenge design reflected growing industry concerns about dependency culture’s costs. Recent data makes the case for constraint-driven skill building:

Security Escalation:

• 512,847 malicious npm packages discovered since November 2023 (156% year-over-year growth)
• September 2025 chalk/debug supply chain attack: 2.6 billion weekly downloads compromised in 16 minutes
• Eighty percent of application dependencies go un-upgraded for over a year.
• Critical vulnerabilities take 500+ days to fix on average

Performance Impact:

• React: 40-45KB gzipped (150KB+ production) vs. Preact: 3KB gzipped (10-13x reduction)
• Real-world bundle reduction: 48% (87KB → 45KB) by aliasing Preact
• Average dependency chain: 4.39 packages deep
• Only 10.5% of npm’s 7+ million packages actively used

Economic Costs:

• Developers lose 33% of time to technical debt
• Companies spend 20-40% of IT budgets managing debt consequences
• One payments SaaS: Dependency cleanup captured $500K in faster revenue

These numbers provided context for Code Olympics’ philosophy. When participants encountered No-Import constraints, they weren’t just solving puzzles—they were building immunity to the reflexive dependency reaching that creates these vulnerabilities.

Historical Context: Constraint-Driven Excellence

The competition’s constraint philosophy has precedent in computing history’s greatest achievements:

Apollo Guidance Computer (1969):

• 4KB RAM, 72KB ROM, 0.043 MHz clock
• Guided astronauts to moon with 30 million times fewer FLOPS than modern computers
• Innovations: Priority-based multitasking, fault-tolerant restarts, real-time scheduling
• Code literally woven into hardware (“rope memory”)

Super Nintendo Development (1990-1997):

• 64KB VRAM, 3.58 MHz CPU
• Mode 7 created pseudo-3D through affine transformations
• Super FX chip: First consumer 3D accelerator (100-200 polygons at 15-20 FPS)
• Donkey Kong Country: Compressed ray-traced 3D graphics into cartridge sprites

id Software Innovations (1990-1996):

• Adaptive tile refresh (Commander Keen)
• Ray casting (Wolfenstein 3D)
• Binary space partitioning (Doom)
• Surface caching (Quake)
• John Carmack noted that far more of the world could run on older hardware if optimization were a priority.

Modern Minimal-Dependency Success:

• SQLite: Most deployed database, depends on only 8 C library functions
• Redis: 100,000 QPS through single-threaded event loop, L1 cache optimization
• Go standard library: Comprehensive functionality with zero external dependencies

Mukhin connected these historical examples to Code Olympics’ goals: “At Yandex, I reduced deployment time significantly by optimizing our build process. That required understanding exactly what our tools did—which dependencies we actually needed versus which were cargo-culted from tutorials. Code Olympics forces that same investigation by making dependencies unavailable.”

The competition design reflected decades of cognitive science research on effective learning:

Desirable Difficulties (Bjork & Bjork, UCLA):

• Challenges that slow initial learning optimize long-term retention
• Increase “germane load”—cognitive resources directed toward lasting learning
• Programming’s “high element interactivity” makes it particularly susceptible to superficial pattern matching

Cognitive Load Theory (ACM systematic review):

• Premature abstraction prevents deeper understanding needed for debugging, optimization, architecture
• When frameworks handle complexity automatically, learners miss foundational concepts

Creativity Under Constraints (145 studies meta-analysis):

• Individuals, teams, organizations benefit from “a healthy dose of constraints”
• Inverted U-curve: Moderate constraints optimize creativity
• Zero constraints diffuse attention; excessive constraints eliminate possibility

Deliberate Practice (K. Anders Ericsson):

• Mere practice creates automaticity and arrested development
• Deliberate practice—sustained focus on tasks you can’t do well—distinguishes elite performers
• Constraints prevent premature automation by ensuring developers can’t rely on familiar solutions

Evaluation Philosophy: What Judges Actually Measured

The scoring system (0-5.0 scale) weighted four criteria:

Criterion	Weight	Key Questions
Functionality & Reliability	40%	Does it work? Is it stable? Does it handle edge cases?
Constraint Mastery	30%	How well did they follow assigned constraints? Creative solutions within limits?
Code Quality	20%	Clean, maintainable, well-structured? Readable despite constraints?
Innovation	10%	Creative approach? Unique solution? Clever implementation?

Mukhin explained his evaluation philosophy: “Functionality mattered most because constraint programming isn’t an academic exercise—it’s about building things people can use. But constraint mastery showed whether teams understood the point. Anyone can write bad code under constraints. Demonstrating how constraints can produce better code—that’s mastery.”

The 10% innovation weight deliberately avoided over-rewarding cleverness. “At Microsoft, I’ve seen brilliant code that nobody could maintain,” Mukhin noted. “Innovation matters, but not as much as reliability and clarity. Code Olympics weights reflect production priorities.”

Category Excellence: Specialized Achievement

Beyond overall placement, the competition awarded $100 prizes for category excellence:

Best Functionality: CuteBunny’s Vist (4.80/5.00)

• Rock-solid reliability across 4 modes
• Automatic GPU/CPU fallback
• Smooth 35 FPS game loop
• Audio-video synchronization
• Zero-crash error handling

Best Constraint Mastery: CalC’s Omni_convertor (4.88/5.00)

• Feature-rich zero-dependency toolkit
• Perfect No-Import Rookie implementation
• Morse code converter without imports
• Judge comment: “Done in the spirit of the hackathon—well written, a breeze to read”

Best Code Quality: beTheNOOB’s TextMind (4.40/5.00)

• Powerful offline text analysis
• Privacy-first approach
• Broad file format support
• Ultra-light footprint

Best Innovation: Ctrl+Alt+Victory’s Sigma Clean (4.67/5.00)

• AI-powered file management
• Robust error-free design
• Intelligence packed into ultra-compact script

Category awards recognized that different projects excelled in different dimensions. Some maximized reliability; others pushed innovation boundaries; still others demonstrated exceptional constraint mastery. All shared commitment to building real, working software without dependency shortcuts.

What Experienced Developers Should Learn

For developers skeptical of constraint programming’s relevance, Code Olympics results offer several challenges to comfortable assumptions:

1. The Framework Dependency Trap is Real

Approximately 40% of initial submissions attempted imports despite No-Import constraints, suggesting unconscious dependency reflexes. When experienced developers reach for libraries before considering built-in solutions, they’ve likely developed blind spots in fundamental capabilities.

2. Constraints Don’t Reduce Quality—They Reveal It

The highest-scoring projects (Vist: 4.480, CalC: 4.88, Code Auditor: 4.420) demonstrated production-grade error handling, architectural clarity, and feature richness despite severe limitations. Constraints didn’t prevent quality—they forced it by making careless implementations impossible.

3. Developer Experience Can Mask Skill Gaps

Mukhin’s observation about fast build times applies broadly: tools that make development faster don’t necessarily make developers better. His own learning accelerated through constraints—building React applications without help, creating automation tools within Microsoft Office’s API limitations, optimizing performance when frameworks didn’t provide solutions.

4. Historical Excellence Proves Constraint Value

Apollo’s guidance computer, SNES game development innovations, SQLite’s architecture, and demoscene achievements aren’t historical curiosities—they’re existence proofs that constraints produce excellence. Modern developers working under artificial abundance may be losing capabilities that previous generations considered fundamental.

Conclusion: What Code Olympics Demonstrated

Over 72 hours, 66 teams proved that real, functional software doesn’t require the dependency scaffolding modern development takes for granted. A professional-grade security scanner in 3 seconds with zero dependencies. A complete multimedia terminal environment handling four operational modes without video libraries. A comprehensive conversion toolkit without imports.

These aren’t toy projects or academic exercises—they’re demonstrations of what becomes possible when constraints force developers past reflexive dependency reaching into genuine understanding. The competition didn’t argue that all dependencies are bad or that production software should avoid libraries. It demonstrated that developers who can build without those dependencies make better decisions about when to use them.

Mukhin’s perspective captures this balance: “At Microsoft, I build tools that help developers work faster—faster builds, better hot reload, smoother workflows. But I also remember building my first React applications with no dependencies, no help, tight deadlines. That constraint-driven learning built intuition about what React actually does, which made me better at optimizing it later. Code Olympics gives developers that same experience in 72 hours instead of years.”

The competition results suggest a pathway forward for an industry grappling with dependency bloat, security vulnerabilities, and concerns about developer fundamental skills. Not abandoning modern tools, but ensuring developers understand them deeply enough to use them wisely. Not rejecting frameworks, but mastering the fundamentals those frameworks abstract away.

When the Apollo Guidance Computer guided astronauts to the moon with 4KB of RAM, it demonstrated what focused engineering could achieve under extreme constraints. When demoscene programmers deliver cinematic experiences in 64KB, they prove constraint-driven creativity remains relevant. Code Olympics 2025’s 66 teams showed these aren’t historical artifacts—they’re capabilities we should be building systematically in every developer, because the next crisis might not give us time to npm install our way out of it.