AI-Assisted Full-Stack Development with Large Models: From Writing Code to Designing Architecture
This article examines how a new generation of large language models has changed AI coding tools, moving them from snippet generators toward architecture collaborators. Using a real multi-module application build, it walks through the shift from writing code to scaffolding structure, covers architecture planning for frontend, backend, AI capabilities and data design, then follows the module-by-module implementation work: content waterfall browsing backed by cloud data, user uploads with client-side image compression, and a full AI image generation chain. It closes with practical VibeCoding methodology and advice on which developer skills remain most valuable as models keep iterating.
Start with the conclusion: from a “code snippet generator” to an “architect colleague”
For a long time, developers’ impression of AI coding tools stopped at the “help me write a carousel” level. You would describe a function-level requirement, get back a block of code, then assemble, debug and patch it yourself. It was essentially smarter code completion. With the latest generation of large models entering these tools, the interaction model has changed fundamentally. The tool no longer waits for you to feed it requirements piece by piece. Instead, it first understands the overall goal, produces a complete technical plan, and then works down layer by layer into code. The following uses a real multi-module application build to unpack what this shift actually means.
1. It is not here to “write code,” it is here to “build the frame”
Start with a compound requirement: build a mobile mini program with waterfall content browsing, user uploads and backend management, plus an AI image generation capability (image analysis, prompt editing, one-click outfit change, image generation).
The traditional approach is for the developer to do technology selection themselves, then have the model generate code segment by segment. The first reaction of this generation of large models, however, is not to rush out code but to deliver an architecture blueprint:
- Frontend selection: adopt the mini program’s native framework and plan three main TabBar pages (Home / AI Generation / Profile).
- Backend selection: adopt a Serverless cloud development model, combining a cloud database, cloud functions and object storage, avoiding the operational burden of self-hosted servers.
- AI capability selection: plan the integration approach for three types of capability, a vision understanding model (for image content analysis), a text generation model (for prompt optimization) and an image generation model (for image-to-image).
- Feature and data design: further enumerate modules such as the wallpaper library (home, album detail, preview, download), AI generation (upload, analysis, editing, outfit change, generation) and the admin console, along with database table structures, cloud function partitioning and file upload compression logic.
The real value of this output is that it makes explicit the “tacit knowledge” that used to depend on decisions inside a senior engineer’s head. Technology selection, module boundaries and data models are laid out in a structured form that people can directly review, add to, remove from or adjust, instead of passively accepting a black box of code.
2. Pairing with a full-stack colleague
Once the architecture is settled, the work moves into module-by-module coding, and the large model’s behavior in several key modules is especially worth noting.
Content waterfall and cloud data
Rather than stopping at “return a page skeleton,” it first designs the cloud database collections and indexes, then generates cloud functions that support pagination and category filtering, and wraps interaction logic such as lazy loading and scroll loading into reusable components. An illustrative cloud function for pagination looks roughly like this:
// Cloud function: paginated fetch of content by categoryexports.main = async (event) => {const { category, page = 0, size = 20 } = event;const db = cloud.database();const skip = page * size;let query = db.collection('wallpaper');if (category) query = query.where({ category });const res = await query.orderBy('createdAt', 'desc').skip(skip).limit(size).get();return { list: res.data, hasMore: res.data.length === size };};
User uploads and storage
The upload module covers common engineering details such as obtaining temporary credentials, client-side image compression and retry on failure, instead of a simple “pick a file, upload it.” Image compression reduces traffic and storage costs while also easing the compute and latency pressure of downstream AI analysis. That non-functional requirements like these are considered proactively is a signal of a capability upgrade.
The AI image generation chain
This is the part that best demonstrates “understanding the whole chain.” The closed loop of upload → AI analysis → editing → generation is connected end to end. The upload component compresses the image automatically, then calls a vision understanding model to analyze it across three dimensions, subject style, image detail and background atmosphere, highlighting key elements. On that basis, the user edits the prompt, a text model optimizes the phrasing, and an image generation model produces the result. Generated results support saving, regenerating and further editing. The whole chain moves forward like a full-stack-savvy colleague working on your behalf.
3. A practical methodology for VibeCoding
VibeCoding is not about casually saying a few words and waiting for output. It actually tests the developer’s ability to state requirements clearly and draw boundaries precisely. A few lessons can be drawn from the practice above:
- Ask for architecture first, code second. Have the model produce technology selection and data models first, get them reviewed and approved by a human, and only then move into coding. This significantly reduces rework later.
- Work in modules and deliver in small steps. Cut a large requirement into independent modules such as content stream, upload and AI generation, then generate and verify them one at a time. This is far more controllable than generating dozens of files in one shot.
- Front-load non-functional requirements. Edge concerns such as compression strategy, pagination limits, credential validity and retry on failure are best agreed on as early as the architecture stage, so you hit fewer pitfalls later.
- Humans provide the backstop. Generating 30+ files in one pass that “runs” is normal, but boundary conditions, security policies and performance bottlenecks still need a developer to review them.
4. Models iterate fast, how should developers keep up?
Seeing large models improve day by day, many engineers feel anxious. Rather than chasing every new release, it is better to focus on the capabilities that are harder to replace:
- Requirement abstraction: translating vague business needs into clear specifications. This is a step the model cannot yet do for you.
- Architecture judgment: selection, decomposition and trade-offs, which determine the long-term maintainability of the system.
- Verification and debugging: a model can generate code, but reading code, locating problems and assessing quality remain core human value.
No matter how strong the tools get, someone still has to steer them. General-purpose cloud capabilities such as object storage, cloud functions, containers, and logging with monitoring and alerting, offered by platforms like Baidu AI Cloud, together with mature AI coding tools, are continuously compressing the path “from idea to a running system.” What ultimately determines the quality of the output is always the developer’s depth of understanding of the problem and their command of the overall solution.
