Code that teaches
AI to code better.
I am a software engineer who designs and solves coding problems, writes clean and clearly explained code, and reviews AI-generated code for correctness, performance, and clarity. That is exactly the work that makes a training signal good: precise problems, idiomatic solutions, and reviews with real engineering judgment behind them. I work across multiple languages including Python, JavaScript, and SQL, write strong technical English, and explain the why behind every solution, not just the what, so the feedback actually improves the next model.
Models are only as good as what trains them.
State-of-the-art AI learns from the code and feedback it is shown. The quality of that input is the entire ballgame, and it takes an engineer to get it right.
Bad training data teaches bad habits
Models learn from the code and feedback they are given. Sloppy snippets or shallow reviews bake errors straight into the next generation of the model.
Correct is not the same as clear
Code that runs is not the same as code that teaches. Without precise explanation of why a solution works, the training signal stays weak and ambiguous.
Reviews need real engineering judgment
Catching subtle correctness, performance, and clarity issues in AI-generated code takes someone who has actually shipped software, not a surface-level checklist.
Every task, treated like production.
I approach each task the way I approach real software: understand the intent behind it, then solve it properly. When I design a problem, I probe the real edges rather than the obvious path. When I write code, it is idiomatic and readable, with the reasoning laid out so a model can learn the pattern, not just the answer. When I review AI-generated code, I check it against correctness, performance, clarity, and established best practices, and I say specifically what is wrong and why, because vague feedback teaches nothing. My background in algorithms, data structures, and debugging workflows means I can move across languages like Python, JavaScript, and SQL and still bring the same rigor, and my written English is strong enough that the explanations stand on their own. The result is training data and evaluations that actually raise the ceiling on what the model can do.
What I bring to the project.
The four core task types this project needs, each handled with production-grade rigor and clear written reasoning.
- Problems that probe real edge cases, not just the happy path
- Clear problem statements with well-defined expected behavior
- Correct, idiomatic reference solutions
- Coverage across difficulty levels and multiple languages
- Readable, idiomatic code snippets in the target language
- Step-by-step technical explanations of the why
- Trade-offs and alternatives called out where they matter
- Writing strong enough to stand on its own as training signal
- Evaluated for correctness, performance, clarity, and quality
- Subtle bugs and edge-case failures caught, not missed
- Best-practice and style issues flagged with reasons
- Consistent, criteria-based scoring across submissions
- Specific, actionable feedback rather than vague notes
- Clear articulation of what a better answer looks like
- Patterns identified so the model learns the general case
- Feedback that holds up to review and rubric alignment
- Comfortable taking projects based on availability and performance
- Consistent quality whether the volume is light or heavy
- Fast ramp on new rubrics, languages, and task formats
- Professional communication and dependable turnaround
My process on every task.
The same four steps behind every problem I write or review. Click any step to see what it means in practice.
In practice
- Clarify the target behavior and constraints up front
- Align to the rubric and quality bar for the task
- Pick the right language and level for the goal
- Identify the edge cases worth probing
In practice
- Idiomatic, readable code in the target language
- Correct reference solutions with edge cases handled
- Clean problem statements with defined expected output
- No shortcuts that would mislead the model
In practice
- Correctness verified against edge cases, not just the demo input
- Performance and complexity considered where relevant
- Clarity and style judged the way a senior reviewer would
- Consistent scoring aligned to the rubric
In practice
- Plain-language reasoning behind every solution or score
- Specific, actionable feedback, never vague
- The general pattern named so the model can learn it
- Writing that stands on its own without extra context
Ready for the assessment.
I meet the requirements, I am located in an eligible country, and I am ready to take the assessment whenever you send the link. I use my real Upwork profile name so the assessment and this proposal match cleanly. Happy to answer any questions before we begin.