AI Agents Can Auto-Generate Projects — Do You Still Need to Learn Deep Learning Code?
AI Agents handle boilerplate code, but catching data leakage still requires deep learning knowledge.
Bilibili creator Qian Yu demonstrated that an AI Agent (Codex) can autonomously handle the entire pipeline — data analysis, preprocessing, training, and visualization — from a raw cat-dog dataset without a single line of human-written code. But his core takeaway isn't "stop learning deep learning." It's the opposite: AI replaces templated engineering work, and the truly critical skill now is auditing AI-generated code. Data leakage — where augmented images from the same source get split across training and validation sets, inflating metrics — is a logical flaw that runs cleanly but can't validate itself. The new learning paradigm centers on understanding project workflows, directing Agents effectively, and code review.
AI Agents Can Generate a Complete Deep Learning Project in One Click
Bilibili creator Qian Yu recently demonstrated a striking experiment in a new video: starting with nothing but a folder of cat-and-dog image data, he handed it over to an AI Agent (Codex in this case) and let the model analyze the data on its own, determine what task could be performed, complete data preprocessing, write a full deep learning project, kick off training, and generate comparison charts — all without the author writing a single line of code.
The end result, starting from a raw dataset folder, was a fully structured project: end-to-end code covering training, validation, and inference, along with automatically generated confusion matrices, ROC curves, training loss curves, and metric plots. Multi-model comparison results were included, and the project was fully reproducible.
This demo raises a pointed question: if AI can build a complete project from scratch, do we still need to learn how to write deep learning code at all?
The Answer Is No: AI Replaces Repetitive Work, Not Judgment
The creator's verdict is clear — no, you can't skip learning it. What AI Agents truly replace is repetitive engineering work: writing a dataset loader class for a training script, scaffolding a complete training pipeline, and other boilerplate, high-repetition code that an Agent can handle just fine.
But that doesn't mean developers can abandon foundational skills. If anything, one critical capability becomes more important: being able to read and verify whether the code AI writes is actually correct. Code that looks complete and runs without errors is not the same as code that's logically sound. If you can't review that code, you're essentially betting your entire project's correctness on the model.
A Classic Pitfall: Data Leakage
The creator uses "data leakage" as a concrete example of why human oversight is indispensable.
Consider this scenario: you have images of cats and dogs. The normal workflow is to split the data into training and validation sets — the training set for learning, the validation set for evaluation. But if you first augment the raw data — say, taking one cat image and spinning it into three via rotation and flipping — and then ask an AI Agent to write the preprocessing code based on that augmented dataset, you have a problem.
The Agent may very well take the three images derived from the same original cat, put the first two in the training set and the last one in the validation set. That's classic data leakage: the model has already seen features of that cat during training, so it naturally performs artificially well on validation. The metrics look great but are completely meaningless.
How to Prevent Data Leakage
The creator offers two approaches: first, be able to read the data loading code in the project and catch issues with how the split is done; second, give the Agent more precise instructions, requiring that it split by individual subject — all three augmented versions of the same original image must go to either the training set or the validation set, never split across both.
Similarly, during data preprocessing, if the model decides on its own to add random noise or blur — operations that may actually hurt performance on the current task — the developer needs to be able to spot and remove them. You can only fix what you can read.
Data leakage is a class of systemic errors in machine learning where information that the model shouldn't have access to during training inadvertently leaks in, causing inflated evaluation metrics that collapse in real-world deployment. Sources vary: beyond the augmented-image cross-split issue described above, common culprits include computing mean/standard deviation on the full dataset before normalization (only training set statistics should be used), using future time-point information in feature engineering (especially fatal in time-series forecasting), and failing to isolate target encoding with cross-validation. What makes data leakage dangerous is that it almost never throws an error — the code runs fine, the metrics look beautiful, and the problem only surfaces after real deployment or re-splitting the data. That's precisely why it's one of the hardest pitfalls for AI-generated code to detect automatically: a model has no way to perceive the semantic relationship that "this image and that image came from the same original sample."
What to Focus on When Learning Deep Learning in the AI Era
From this, the creator draws his core argument: in the age of AI Agents, the focus of learning should shift. You no longer need to hand-code entire projects from scratch — hand that repetitive work to the Agent. But these three capabilities remain essential:
- Understand the complete project workflow: know what each stage of a deep learning project is doing, from data to training to evaluation.
- Learn to direct the Agent effectively: be able to describe tasks clearly and guide the Agent toward building a well-structured project.
- Develop the ability to review code: be able to audit Agent-generated code and catch issues like data leakage and improper preprocessing.
In other words, you still need to learn deep learning — the form just evolves from "writing code" to "reading code + designing workflows + quality control."
This shift in skill emphasis closely mirrors the evolution in software engineering between "system design" and "coding implementation." As tools like code autocomplete and automated unit test generation have matured, engineers' core competency has long since moved from "can hand-implement any algorithm" to "can design system boundaries, review code quality, and define acceptance criteria." The shift happening in deep learning is the same trend playing out in a more specialized domain: baseline setup and boilerplate code — tasks that once required repeated manual effort — get delegated to Agents, while the soundness of experimental design, correctness of data handling, and interpretation of evaluation metrics demand human domain judgment. "Knowing how to use Agents" and "understanding deep learning" are therefore not an either-or trade-off — they're complementary capabilities. The former boosts execution speed; the latter ensures results you can trust.
Supporting Resources: Prompt Docs and a Learning Roadmap
To help viewers put this into practice, the creator also compiled a prompt document for project setup, covering how to build a project from scratch, how to clearly describe the task and data, how to analyze before building, and how to understand a deep learning project — including data inspection, debugging, baseline setup, and optimization analysis based on the problem at hand.
The creator also shares a suggested learning path: start with Python, move to traditional machine learning, then advance into modern deep learning, with starter project resources attached for each direction. These materials, he notes, will be posted in the comments section for anyone to grab.
Closing Thoughts
The value of this video isn't in showing off what AI can do — it's in offering a practical judgment framework. AI Agents are powerful productivity tools that dramatically lower the barrier to engineering implementation. But what they lower is the barrier to writing; what they raise is the barrier to judgment. Pitfalls like data leakage illustrate exactly why there's a massive gap between code that runs and code that's correct — and the only thing that bridges that gap is someone who understands the principles and knows how to review the work.
Related articles
Random Pruning of the DPO Computation Graph: 1.4x Training Speedup and Lower Peak Memory
DPO training too slow and memory-hungry? This paper proposes a random pruning framework for the DPO computation graph, sampling independently across position, sequence, and branch dimensions; branch pruning achieves a 1.426x step-time speedup and cuts training time by about 30%, with in-depth attribution of memory and time gains.
Why Does JEPA Underperform MLM in Longitudinal EHR Representation Learning?
New study compares JEPA and MLM for longitudinal EHR representation learning on MIMIC-IV: three JEPA variants train stably without collapse but underperform MLM; target size, not heterogeneity, drives prediction error.
Transfer Learning + Visible Light Communication: A New Approach to Energy-Efficient Indoor Positioning
A study proposes a transfer learning-based visible light communication indoor positioning method, achieving 47% accuracy improvement on the BOSCH factory dataset, 67.5% model efficiency under high noise, and introducing the ME composite metric for energy-efficient positioning in energy-constrained industrial IoT scenarios.