Most coding platforms train engineers to solve isolated algorithm problems.
But in real engineering, you rarely reverse linked lists.
- You debug production systems.
- You trace issues across files.
- You deal with incomplete logs, unexpected states, and systems you didn’t write.
so I built something around that.
Introducing Recticode
Recticode is a platform focused on real-world debugging challenges.
Instead of algorithm puzzles, engineers work with realistic multi-file codebases that contain subtle production-style bugs.
The 4-week system
Instead of a single hackathon, I split it into two connected phases:
Phase 1: Challenge Sprint (May 4 – May 31)
Engineers submit real debugging challenges.
Each submission is:
- multi-file (real code structure)
- contains a subtle production-style bug
- includes expected behaviour + context
- written like a real engineering system
The goal is to build a library of realistic debugging problems.
Phase 2: Debugging Championship (June 1 – June 14)
Engineers then compete to solve these challenges.
A public leaderboard tracks:
- correctness
- consistency
- difficulty-weighted performance
This turns submitted challenges into a live competition system.
Why I built this
I kept noticing a gap between:
what coding platforms teach
and
what real engineering actually looks like
Most practice focuses on:
- algorithms in isolation
- clean inputs
- nno system complexity
But real work is:
- debugging distributed systems
- reading unfamiliar codebases
- tracing state across multiple layers
So I wanted a format that reflects that.
What i’m hoping to learn
This is still early, but i’m mainly trying to answer:
- do engineers prefer debugging-based practice?
- can a "challenge library" become a real learning system?
- will people actually engage with this over time?
If you want to try it:
Challenge Sprint is live now: https://recticode.com
Recticode is also fully open source on GitHub.
github.com
Recticode
Practice real-world coding by fixing bugs in actual codebases, not solving toy problems.
What is this?
Recticode is a cli-based platform where you:
- pull a coding challenge (a real mini codebase)
- identify and fix a bug or implement a feature
- run your own tests to verify your solution
- submit your fix
Instead of writing isolated functions, you work with realistic systems.
Why?
Most platforms train you to:
- solve algorithm problems from scratch
But real dev work is more like:
- reading existing code
- debugging issues
- making safe changes without breaking things
Recticode is built to train that skill.
How it works
- install the CLI
- fetch a challenge
- work locally in your editor
- run your own tests
- submit your solution
Installation
pip install recticode
Check it works:
recticode --help
Example Flow
# login
recticode login
# get a challenge
recticode start <challenge-name>
# work on the code locally...
# submit…
Submissions are open until may 31.
Feedback Welcome
Especially interested in:
- whether this feels closer to real engineering than leetcode-style platforms
- what would make debugging challenges more useful for learning or hiring