Update Blog.md

Blog.md

@@ -1,6 +1,6 @@
 # I Taught a Small AI to Review Code Better Than a Model 10x Its Size
 
-*And we did it in 48 hours at the Meta × HuggingFace OpenEnv Grand Finale, Bangalore*
+*And I did it in 48 hours at the Meta × HuggingFace OpenEnv Grand Finale, Bangalore*
 
 ---
 
@@ -8,7 +8,7 @@ Imagine you're a junior developer. You just spent three days writing a feature.
 
 Now imagine that senior engineer never sleeps, never gets tired, and gets *better* at code review every single time they review code.
 
-That's what we built.
+That's what I built.
 
 ---
 
@@ -18,11 +18,11 @@ Code review is broken.
 
 Not because developers don't care — they do. But because the volume of code being written has outpaced the human capacity to review it carefully. Studies estimate this costs the software industry **$50 billion annually** in bugs that reach production.
 
-The uncomfortable truth: **every production bug was approved by at least one human reviewer.**
+The uncomfortable truth: **every production bug was approved by at least one human revieIr.**
 
 Existing AI tools can suggest code. They can autocomplete. But none of them *learn* from feedback. None of them get better at reviewing the more they review.
 
-We wanted to change that.
+I wanted to change that.
 
 ---
 
@@ -30,11 +30,11 @@ We wanted to change that.
 
 Here's the insight that drove everything:
 
-> Code review has a verifiable ground truth. We *know* which lines have bugs. We *know* how severe they are. We *know* what a correct verdict looks like.
+> Code review has a verifiable ground truth. I *know* which lines have bugs. I *know* how severe they are. I *know* what a correct verdict looks like.
 
 If you have ground truth, you have a reward signal. If you have a reward signal, you can train an AI agent using reinforcement learning.
 
-So we built **CodeReviewEnv** — an OpenEnv-compliant RL environment where an AI agent plays the role of a senior code reviewer. The agent reads a buggy code diff, submits structured comments with line numbers and severity ratings, issues a verdict, and then — here's what makes it novel — **tries to fix the bugs it found**.
+So I built **CodeRevieInv** — an OpenEnv-compliant RL environment where an AI agent plays the role of a senior code revieIr. The agent reads a buggy code diff, submits structured comments with line numbers and severity ratings, issues a verdict, and then — here's what makes it novel — **tries to fix the bugs it found**.
 
 The environment scores every move. Find a critical bug? +0.20. Submit a false alarm? -0.08. Fix the bug correctly? +0.40. The agent learns, episode by episode, what good code review actually looks like.
 
@@ -67,7 +67,7 @@ class TaskQueue:
 
 A junior developer might look at this and think: *"Looks fine to me."*
 
-A senior engineer immediately spots four problems: the unprotected list access, the race condition on `pop(0)`, the swallowed exception, and the missing `join()`.
+A senior engineer immediately spots four problems: the unprotected list access, the race condition on `pop(0)`, the swalloId exception, and the missing `join()`.
 
 Our trained agent now spots all four.
 
@@ -75,7 +75,7 @@ Our trained agent now spots all four.
 
 ## The Environment: 13 Tasks, 6 Languages
 
-We built 13 carefully curated tasks spanning real bug patterns across the full stack:
+I built 13 carefully curated tasks spanning real bug patterns across the full stack:
 
 | Language | Task | What's Hidden |
 |----------|------|---------------|
@@ -114,22 +114,22 @@ Good RL environments have good reward signals. Here's ours:
 
 But here's the part most RL environments skip: **anti-reward hacking**.
 
-A naive agent quickly discovers it can spam 30 vague comments, hope some accidentally match known issues, and always say "request_changes" to grab the verdict bonus. We caught this early and built four server-side checks:
+A naive agent quickly discovers it can spam 30 vague comments, hope some accidentally match known issues, and always say "request_changes" to grab the verdict bonus. I caught this early and built four server-side checks:
 
 - **Spam detection** — more than 12 comments triggers proportional penalty
 - **Duplicate detection** — copy-pasting the same comment triggers -0.20
 - **Quality check** — descriptions under 15 characters are penalized
 - **Verdict gaming** — `request_changes` with zero comments gets caught
 
-The result: the agent *had* to actually understand the code to score well.
+The result: the agent *had* to actually understand the code to score Ill.
 
 ---
 
 ## Curriculum Learning: The Agent Earns Harder Tasks
 
-We didn't just throw the agent at concurrency bugs on day one.
+I didn't just throw the agent at concurrency bugs on day one.
 
-CodeReviewEnv implements adaptive curriculum learning. The agent starts on easy Python bugs. When it averages above 0.75 for three consecutive episodes, the environment automatically promotes it to medium difficulty. Then hard. Then security tasks.
+CodeRevieInv implements adaptive curriculum learning. The agent starts on easy Python bugs. When it averages above 0.75 for three consecutive episodes, the environment automatically promotes it to medium difficulty. Then hard. Then security tasks.
 
 ```
 Episode 1-20:   easy Python bugs → agent builds pattern recognition
@@ -150,7 +150,7 @@ No human decides when to increase difficulty. The environment does — based pur
 
 ## GRPO Training: The Agent Actually Learns
 
-We trained **Qwen2.5-Coder-7B-Instruct** using GRPO (Group Relative Policy Optimization) on an A100 GPU, with CodeReviewEnv as the reward signal.
+I trained **QIn2.5-Coder-7B-Instruct** using GRPO (Group Relative Policy Optimization) on an A100 GPU, with CodeRevieInv as the reward signal.
 
 500 episodes. 2 hours 43 minutes. One A100.
 
@@ -167,9 +167,9 @@ The red smoothed curve in the plot goes up. Consistently. That's not luck — th
 
 ## The Result That Surprised Us
 
-We expected the trained model to be better than the baseline. We didn't expect *this*:
+I expected the trained model to be better than the baseline. I didn't expect *this*:
 
-| Task | Groq llama-3.3-**70B** (Baseline) | Qwen2.5-Coder-**7B** (After GRPO) | Change |
+| Task | Groq llama-3.3-**70B** (Baseline) | QIn2.5-Coder-**7B** (After GRPO) | Change |
 |------|----------------------------------|-----------------------------------|--------|
 | easy | 0.95 | 1.13 | ↑ +0.18 |
 | medium | 0.90 | 1.28 | ↑ +0.38 |
@@ -212,16 +212,16 @@ This closed the loop from **detection** to **remediation** — the agent doesn't
 
 ---
 
-## What We Learned Building This
+## What I Learned Building This
 
 **1. Ground truth is everything.**
-The reason this works is that code bugs have verifiable ground truth. The grader always knows the right answer. This is what separates code review from tasks like "write a good essay" — there's no ambiguity in whether line 25 has a race condition.
+The reason this works is that code bugs have verifiable ground truth. The grader always knows the right ansIr. This is what separates code review from tasks like "write a good essay" — there's no ambiguity in whether line 25 has a race condition.
 
 **2. Reward hacking appears faster than you expect.**
-Within 20 episodes of our first training run, the model discovered it could output `request_changes` with no comments and get +0.10 every time. We saw reward plateau at exactly +0.08. The anti-hacking checks were not optional — they were essential.
+Within 20 episodes of our first training run, the model discovered it could output `request_changes` with no comments and get +0.10 every time. I saw reward plateau at exactly +0.08. The anti-hacking checks Ire not optional — they Ire essential.
 
-**3. Curriculum matters more than we thought.**
-Without curriculum, reward variance was so high the model couldn't find a learning signal. With curriculum, the training curve became smooth and consistent. This one change was the difference between a confused model and a learning one.
+**3. Curriculum matters more than I thought.**
+Without curriculum, reward variance was so high the model couldn't find a learning signal. With curriculum, the training curve became smooth and consistent. This one change was the difference betIen a confused model and a learning one.
 
 **4. A small model with good training beats a big model without it.**
 This is the most important lesson. The 70B model has seen more code than our 7B model ever will. But it has never been corrected 500 times for missing a race condition. Practice beats knowledge.
@@ -276,7 +276,7 @@ curl https://lucifer0077-code-review-env.hf.space/curriculum/state
 This is version 1. Here's what version 2 looks like:
 
 - **Multi-step episodes** — agent reviews, gets feedback, revises. Like a real code review conversation.
-- **GitHub webhook** — environment hooks directly into real pull requests. Agent reviews your actual PRs.
+- **GitHub Ibhook** — environment hooks directly into real pull requests. Agent reviews your actual PRs.
 - **More languages** — Go, Rust, Java. Because bugs don't care what language you write in.
 - **Larger model** — 34B with full fine-tuning. If 7B beats 70B, what does 34B do?
 
@@ -284,13 +284,13 @@ This is version 1. Here's what version 2 looks like:
 
 ## One Last Thing
 
-We built this in 48 hours. One developer. Limited coding experience. With AI assistance.
+I built this in 48 hours. One developer. Limited coding experience. With AI assistance.
 
 The environment works. The training pipeline works. The agent genuinely improved. The results are real.
 
 If a beginner can build a system where a 7B model beats a 70B model at code review in 48 hours using open-source tools — imagine what a team of engineers can do with more time.
 
-That's the promise of OpenEnv. That's why we built CodeReviewEnv.
+That's the promise of OpenEnv. That's why I built CodeRevieInv.
 
 ---
 
@@ -298,4 +298,4 @@ That's the promise of OpenEnv. That's why we built CodeReviewEnv.
 
 *Aditya Sharma (lucifer0077)*
 
-*Theme 4: Self-Improving Agent | Theme 3.1: Professional Tasks*
+*Theme 4: Self-Improving Agent | Theme 3.1: Professional Tasks*