11.07 · AI Agent Workflow Discipline¶

When you touch this: Every day of the 13 months. Reread at M1, M4, M7, M10 as a sanity check.

You already use AI agents heavily — that is your daily reality as an ML engineer at Zoho, and it is not something you can (or should) turn off. What you can do is impose rules on when the agent writes for you versus when you write for yourself. Skip this discipline and you will graduate M13 with a portfolio full of code you can neither explain in an study nor debug in production.

The pattern is simple and non-negotiable: AI on second draft only, during M1-M8. From M9 onward, you loosen up — by then your mental model is strong enough that Copilot cannot smuggle a bug past you.

The Core Rule (Print This, Tape It To Your Monitor)¶

First draft: hands only. Second draft: agent allowed. Never the reverse.

You will write the first version of every function, every test, every SQL query in month 1 through month 8 without an AI in the loop. Then, once your working solution compiles and passes tests, you may open Claude/Cursor/Copilot and ask “how would you have done this?” or “review this for idiomatic Java 21.” That is when learning happens — in the delta between your version and the improved one.

If you let the agent go first, you are back to being a code-review approver. That is what the job market is unbundling. You are trying to become the person who can write it.

When AI IS Allowed (Green Light)¶

Situation	Why
Researching an unknown (“what’s the modern way to structure a Spring Data audit trail?”)	Fastest path to the map. Verify with docs after.
Reviewing your finished code (“here’s my `UserService`, is anything unidiomatic?”)	The classic 2nd-draft review. Highest ROI.
Explaining a stack trace or JMH output	Faster than Google, usually correct. Double-check any claim about JVM flags.
Boilerplate you already understand (getters, DTO mapping, Testcontainer setup)	You’ve written it 20 times. Copilot autocomplete is fine.
Diagram / doc drafting (README skeletons, ADR templates)	Prose acceleration is fine.
DevOps YAML you understand structurally (a K8s deployment for the 5th time)	Same as above.
Debugging a specific error (“why does this `@Transactional` not roll back?”)	Only after you’ve read the stack trace yourself for 5 minutes.

When AI IS NOT Allowed (Red Light — M1-M8)¶

Situation	Why
DSA practice problems (LeetCode, NeetCode)	The whole point is to build the muscle. Copilot writes the solution; your neurons don’t fire.
First-pass writing of any new concept	You need to feel the friction. That friction is the learning.
Concurrency primitives (locks, semaphores, `CompletableFuture`)	Agents get concurrency subtly wrong. You must reason it out yourself.
Cracking a JEP or JLS section	Read the source spec. Don’t ask AI to summarise the spec that took 5 experts a year to write.
study-style whiteboard problems	Zoho / product-company studies often go screen-share, no editor. If Copilot writes your Java, you’ll freeze in the study.
Design discussions in your head	Sketch on paper. Talk out loud. The AI collapses your solution space too early.
Reading stack traces for the first 2 minutes	Train the reflex first. Then ask for help.

The Tools — Ranked for Java (2026)¶

Tool	Cost	Best for	Verdict
JetBrains Junie (in IntelliJ)	Bundled with IntelliJ AI subscription (~$10/mo, ~₹850)	Agentic Java editing inside IntelliJ	Best-in-class for Java-native context (understands `pom.xml`, refactoring intents). Use in M9+.
GitHub Copilot	$10/mo (~₹850), free for students/OSS	Line completion in IntelliJ / VS Code	Fine for autocomplete. Turn off during LeetCode.
Claude Code / Cursor	Cursor $20/mo (~₹1,700), Claude Pro $20/mo	Whole-file rewrites, multi-file refactors	Excellent for M9+ portfolio work. Use for code review after you write.
ChatGPT / Claude web	$20/mo	Research, “explain this”, diagram drafting	Baseline. Free tier is often enough.
Amazon Q Developer	Free tier generous, Pro $19/mo	If your team lives in AWS	Second choice for AWS-heavy shops.
JetBrains AI Assistant	Bundled or $10/mo	Refactoring, commit messages	Weaker than Junie but built-in.

If Zoho gives you a Copilot licence (some teams do), take it. Otherwise start with Claude Pro + IntelliJ built-in AI at ~$30/mo (~₹2,550).

The Month-by-Month AI Dial¶

Month	AI level	Rule
M1-M2 (fundamentals refresh)	Off	Hands only. Feel every syntax.
M3-M4 (DSA + core Java)	Off for practice, On for review	Second-draft rule.
M5-M6 (design patterns, concurrency, JVM)	Off	Concurrency + JVM are where AI hallucinations bite hardest.
M7-M8 (Spring, data, distributed basics)	Second-draft only	You will be tempted. Resist.
M9 (integration + testing)	Half-on	Testcontainer setup, boilerplate, YAML — fine. Business logic — hands.
M10-M11 (portfolio project)	Full agent-augmented	Ship real work. Use every tool. This is the industry reality.
M12 (studies + polish)	Off during mock studies	Because Zoho studies are still screen-share whiteboard.
M13 (job hunt, prep talks)	Full-on for logistics, off for algorithms	Cover letters yes. Coding round no.

The “Second Draft” Protocol¶

When you finish a function or a class the hard way, run this before moving on:

Commit your version. git commit -m "first-pass User service". This is non-negotiable — you preserve the record of what you can do unassisted.
Ask the agent for review. “Here’s my implementation. What would you improve? Focus on idiomatic Java 21, thread safety, and testability. Don’t rewrite — just critique.”
Read every suggestion. For each, decide: valid / wrong / matter of taste. Write one-line notes on why.
Apply only the valid ones, and only after you understand why they are improvements.
Commit again. git commit -m "apply review: use Optional properly, extract mapper".

The two commits, side by side, are your learning log. In month 6 you should look back at month 2’s commits and cringe. That is the point.

Prompts That Actually Help (Not Just Write My Code)¶

“Explain the trade-off between synchronized and ReentrantLock in this specific method — don’t rewrite it.”
“What are three JVM flags I’d tune if this service does 90% reads and only 10% writes? Give the reasoning.”
“Point out any place where I’m violating the Law of Demeter or leaking abstraction.”
“If a senior Zoho engineer reviewed this PR, what’s the first comment they’d leave?”
“Give me three failure scenarios my tests don’t cover — don’t write the tests.”

Note the pattern: you ask for critique and reasoning, not code. Code is the cheap output. Judgement is the expensive one, and that’s what you’re building.

Anti-Patterns to Kill Now¶

Copy-pasting the agent’s stack trace explanation into a comment — you didn’t learn, and the comment is now a landmine.
Letting Copilot generate your test names — test names encode intent. Write them yourself.
Asking the agent for architecture without giving it constraints — it will produce generic mush. Constrain: “3 developers, 500 requests/sec, must run on 2 GB RAM.”
Trusting the agent on JVM internals or GC behaviour — hallucination rate is high here. Cross-check with Shipilëv’s blog or docs.oracle.com.
Using the agent as a rubber duck without ever pushing back — if it agrees with everything you say, you’re not learning. Force it to disagree: “Argue against my approach.”

The Zoho / study Reality¶

Zoho’s study loop is well-known for being paper-and-pen or shared-editor with no autocomplete. Same for most product companies (Freshworks, CRED, Razorpay, PhonePe, PayPay). If you have trained your fingers to expect Copilot suggestions, you will freeze the moment the editor goes silent.

Countermeasure: during M12, do 3-5 mock studies in a plain text editor with AI disabled — Sublime, Notepad++, TextEdit. Feel the discomfort now. Diagnose which fundamentals crack under pressure. Fix them before the real study.

Practice Milestones¶

End of M1: You have committed at least 20 first-draft files with no AI touch. Prove it via git log --author=you.
End of M4: You have written at least 100 LeetCode solutions with autocomplete/Copilot fully disabled in IntelliJ (Settings → Tools → GitHub Copilot → off).
End of M8: You have a running log (in 13_discipline/) of at least 30 “second-draft” agent reviews with your notes on which suggestions you accepted vs rejected and why.
M12 mock: 3 mock studies in a plain editor. If you flail, you are not ready. Circle back.

Return to README.md · Next: 08_hardware_and_workspace.md