The Age of AI Agents: Do We Still Need to Write Deep Learning Code Ourselves?

AI Agents Can Build Deep Learning Projects from Scratch

With the rise of AI coding assistants like Codex and Claude, a pressing question faces every AI practitioner and graduate student: if an Agent can write the code for us, do we still need to learn how to implement deep learning projects by hand? Bilibili creator Qianyu tackled this question with a hands-on demo.

The setup was straightforward: start with a cat-and-dog image classification dataset, hand it to an AI Agent (like Codex), and let it autonomously figure out what task to perform, handle data preprocessing, write a complete deep learning project, run training, and plot comparison results across different models.

Not a single line of code was written by the human operator. The result: starting from a folder of raw data, a fully structured project emerged — complete with confusion matrices, ROC curves, training loss plots, and metric charts. Training, validation, and inference code were all included, and the project was fully reproducible.

This demo makes one thing clear: AI Agents genuinely can assemble an end-to-end deep learning project automatically, taking over the repetitive manual work that used to require hours of coding.

Does That Mean We Can Stop Learning to Code?

The answer is no. The creator is explicit: AI only handles the repetitive labor — things like writing a dataset loader class in a training script or scaffolding a full training pipeline. Agents can manage that mechanical work, but that doesn't mean we can abandon our ability to understand code altogether.

The real key is this: we must be able to read and review the code AI writes. AI-generated code may run and produce results, but whether those results are correct and whether the pipeline has hidden flaws requires human judgment. If you can't follow the logic of the code, you can't assess whether the project an Agent delivers is actually reliable.

In other words, the repetitive labor of writing code can be outsourced to an Agent — but the ability to judge the quality of the output cannot. That's precisely where human value remains irreplaceable in the age of AI.

Data Leakage: The Hidden Trap AI Often Falls Into

The creator uses the classic problem of data leakage to illustrate why understanding code matters so much.

Here's the scenario: images of cats and dogs need to be split into a training set and a validation set. If you first apply data augmentation to the raw images — say, rotating and flipping one cat photo to produce three versions — a subtle problem can emerge.

When you ask an Agent to write the data-splitting code based on the augmented dataset, it will very likely place the first two versions of the same cat in the training set and the third in the validation set. That's classic data leakage: the model has already seen that cat's features during training, so validation metrics will be artificially inflated and the evaluation results can no longer be trusted.

How do you prevent it? Two approaches: either understand the data loading code well enough to catch the issue yourself, or give the Agent more precise instructions — specifically, require it to split by individual subject: all three augmented images from the same cat must go entirely into the training set or entirely into the validation set.

Similarly, during data preprocessing, certain augmentation techniques (such as random noise or blur) may negatively impact specific tasks. A human needs to evaluate and remove those. All of these judgment calls depend on a genuine understanding of the deep learning pipeline.

Deep Dive: Data Leakage Data leakage (Data Leakage) is one of the most common and hardest-to-detect mistakes in machine learning. At its core: the model gains access during training to information that should only be available during evaluation, causing validation metrics to be inflated while the model's real-world generalization falls far short of what the numbers suggest. Leakage in data augmentation scenarios is a classic form of "sample-level leakage" — when multiple augmented samples come from the same original image (the same cat), if the split is done randomly rather than by original subject, information about the same entity ends up in both the training and validation sets, effectively letting the model "memorize the answers." Another common form is "feature leakage," where preprocessing uses statistics from the validation set (such as mean and variance) to normalize the training set, which also distorts evaluation. Recognizing and avoiding these issues depends on systematic understanding of the entire deep learning pipeline — not just coding ability.

Where Should Learning Focus in the Age of AI?

The conclusion is clear: deep learning is still worth learning — the emphasis has simply shifted.

In the past, we wrote project code from scratch. Today, that repetitive work can be handed off to Agents. What we should invest our energy in instead comes down to three things:

• Understand the complete project pipeline: know the full picture of a deep learning project — from data to model to evaluation
• Learn to direct Agents effectively: describe tasks clearly, specify data locations, and guide the Agent to analyze before it builds
• Develop the ability to review code: be able to spot issues like data leakage and preprocessing errors

The creator also shared a "project-building prompt document" covering how to build a project from scratch (task description, data location, analyze-then-build approach), how to understand a deep learning project (data inspection, debugging, building a Baseline, optimization analysis), and other practical guidance.

For beginners, the suggested learning path is: start with Python fundamentals, move to traditional machine learning, then advance into modern deep learning — working through introductory projects in each area step by step.

Deep Dive: Baseline "Baseline" is a key concept in deep learning project development. It refers to running the entire pipeline with the simplest, most standard approach first — before any serious optimization — and recording that initial performance number as a reference point. The value of a Baseline lies in being the benchmark against which all future improvements are measured. Only by first establishing "what can the most basic approach achieve?" can you meaningfully judge whether subsequent data augmentation, model improvements, or hyperparameter tuning actually make a difference. When directing an Agent to build a project, instructing it to "build a Baseline before optimizing" is an effective prompting strategy. It prevents the Agent from introducing overly complex modules from the start, which would make debugging and result validation much harder. This mindset is also a reflection of standard industry practice and research methodology.

Final Thoughts

What AI Agents change is how things get done — not whether you need to understand them. Agents automate the repetitive, mechanical side of coding, but that only makes the control of quality, correctness, and methodology more critical than ever. The gap between someone who can use an Agent and someone who can audit an Agent will be ruthlessly exposed the moment a subtle issue like data leakage appears.

For graduate students and AI learners, the real foundational skill is no longer memorizing APIs or typing fast. It's understanding the pipeline, directing the tools, and reviewing the output. That is the core competitive edge in the age of Agents.