LLM-Assisted Coding in Practice: Capability Boundaries and a Guide to Common Pitfalls

    This article shares hands-on lessons from a developer who used AI coding assistants intensively over a long period, with cumulative token consumption approaching a billion. Its central argument is that an LLM is a powerful copilot but must not be blindly trusted in real engineering: it drafts, and the human reviews and finalizes. The article breaks down seven high-frequency pitfalls—throughput fluctuation, weak reasoning depth and global planning, unreliable execution plans, ignored constraints, subtask attention drift, poor handling of visual details, and misinterpretation of ambiguous instructions—and distills five practical strategies: human review gates, explain-before-execute prompts, making rules executable through automated validation, making context explicit, and layered acceptance. The takeaway is to combine the model's drafting speed with human oversight so that efficiency gains do not come at the cost of unacceptable risk.

    Introduction: From “Impressive Demos” to Real Engineering

    After large language models entered the field of coding assistance, many teams experience a similar psychological arc: they are initially awed by the model’s fluent code-generation ability, and then, after integrating it deeply into daily development, gradually discover that its performance in real, complex, constraint-heavy engineering environments falls far short of what the demos promised.

    This article does not review any specific product. Instead, from the perspective of a developer who has used AI coding assistants extensively over a long period, it abstracts and categorizes the problems that recurred during a period of intensive practice (with cumulative consumption approaching a billion tokens) and distills a reusable judgment framework and set of pitfall-avoidance methods. The core conclusion is a single sentence: an LLM is a powerful “copilot,” but the “human captain” must retain authority over key decisions.

    Section 1: Overall Experience — Usable, but Never Blindly Trusted

    Over extended use, several relatively stable positive characteristics can be observed: outputs are basically free of garbled text, the generation ability for frontend and interface tasks is fairly solid, overall throughput is stable, and as long as the plan quota is sufficient, even several consecutive hours of intensive sessions will not hit usage limits.

    But there is a clear gap between “it runs” and “it’s reliable.” The core requirement of real engineering is a correct implementation that is maintainable, verifiable, and compliant with business constraints, whereas the solutions a model generates usually require repeated manual verification and further back-and-forth before they can be put into use. Therefore, a reasonable mental model is not “it does the work for me,” but “it drafts for me, and I review and finalize.”

    Section 2: Breaking Down Typical Problems — Seven High-Frequency Pitfalls

    1. Response Speed and Throughput Fluctuation

    Generation speed varies noticeably across different times of day—clearly slower during peak load periods and relatively smooth during off-peak periods. For coding scenarios that require frequent interaction, this fluctuation can significantly interrupt flow. A practical recommendation is to schedule long-running batch generation tasks during off-peak hours and reserve the more interactive, detailed debugging for windows when responses are faster.

    2. Insufficient Reasoning Depth and Global Planning Ability

    This is the most strongly felt problem. The model often “only does what’s right in front of it,” with shallow thinking, incomplete consideration, and a tendency to fix one thing while breaking another. A typical contrast: when asked to summarize “what changed in the new version,” a weaker performance only addresses the differences of the single most recent version, while a better performance systematically summarizes all the version changes within the given range. This suggests that the model’s global perspective and proactive gap-filling awareness are not stable.

    3. Plan Reliability: Always Add a “Human Gate”

    The execution plans generated by the model often need to be reviewed item by item and re-communicated before they can be used. For example, when asked to generate a load-testing script, the program may run successfully yet completely fail to apply any real load—a product that is “syntactically correct but semantically invalid.”

    To address this, I have developed a practical technique: after generating a plan, append a constraining prompt—effectively adding a human gate, as illustrated below:

    1. Don't execute anything yet. First explain:
    2. 1. How you plan to do it, step by step;
    3. 2. What the final deliverable will look like;
    4. 3. What criteria you'll use to judge that it's "done correctly."
    5. Wait for my confirmation before you start.

    This step turns “silent execution” into “align first, then implement,” greatly reducing the rate of rework.

    4. Rule and Constraint Adherence: Documented Rules May Still Be Ignored

    Another high-frequency problem is the disregard of established rules. Even when a rules document explicitly states that “execution must go through a specific containerized approach” and provides the steps, the model may still try to run directly on the local machine. This indicates that the “attention weight” of critical constraints within a long context is unstable. The coping strategy is to upgrade hard constraints from “documented description” to “executable validation”—for example, using scripts or hooks to forcibly check the runtime environment before critical steps, rather than relying solely on natural-language descriptions.

    5. Subtask Distribution and Attention Drift

    Under multi-agent/subtask orchestration modes, it is common to see subagents “do the wrong work or do too much work”—a subtask that should focus on a single module instead oversteps and modifies other parts. Notably, the severity of this kind of problem varies greatly across different versions or different tools, which indicates that explicitly declaring task boundaries is crucial. In practice, when dispatching subtasks, you should clearly write out a “change-scope whitelist” and a “do-not-touch list.”

    6. Output Quality: Visual and Detail-Oriented Tasks Easily Go Wrong

    In refactoring tasks, an obvious weakness is insufficient sensitivity to visual details. For example, a color problem with the homepage button may take multiple rounds of modification before it is even discovered and fixed, and it often ultimately requires direct human intervention at the style layer to resolve. This shows that the model’s “structural understanding” of the source code is adequate, but it lacks a feedback loop for the “actual rendered result.” A reasonable approach is to pair it with a real-time visual preview, letting the model converge within a “modify—view—modify again” loop rather than blindly trial-and-error.

    7. Logic and Instruction Understanding: Bias in Ambiguous Scenarios

    When the instruction itself is somewhat ambiguous (for example, wording that involves time ranges or version ranges), the model tends to interpret it in the most literal way and arrive at conclusions that deviate from the intent. Rather than complaining that “it can’t reason its way around it,” it is better to start with instruction design: explicitly provide a time baseline, clearly specify the start and end of the range, avoid ambiguous pronouns, and make implicit context explicit.

    Section 3: Engineering Pitfall-Avoidance Strategies — Five Actionable Methods

    Synthesizing the above problems, a pragmatic set of engineering methods can be distilled:

    • Human review gate: For any plan that affects architecture, data, or external behavior, review before executing, keeping key decision-making firmly in human hands.
    • Explain before executing: Use a prompt that requires “explaining the approach and acceptance criteria” to constrain the model, turning black-box execution into aligned collaboration.
    • Make rules executable: Convert hard constraints from natural-language descriptions into automated validation (environment checks, boundary checks, pre-commit hooks), reducing reliance on the model’s “memory.”
    • Make context explicit: Proactively fill in background information such as time, version, scope, and term definitions to reduce comprehension bias caused by ambiguity.
    • Layered acceptance: Verify generated results level by level—“compiles → passes tests → complies with business rules → correct visually and interactively”—to establish an observable quality loop.

    Section 4: Summary — Rationally Positioning the Role of LLMs

    The truly mature way to use LLMs is not to search for an “omnipotent model,” but to build a “human-machine collaboration” engineering process around the model. LLMs excel at rapid drafting, batch generation, and offering multiple candidate solutions; humans are responsible for defining goals, reviewing plans, gating quality, and bearing ultimate responsibility.

    Treat the model as a collaborator with bounded capabilities, an attention span that can drift, and a need for explicit constraints—align with it through prompt engineering, back it up with automated validation, and safeguard quality with layered acceptance. Only in this way can you enjoy the efficiency dividend while keeping risks within an acceptable range. This is both the most valuable lesson from long-term intensive practice and the prerequisite for genuinely integrating AI coding assistants into a professional development workflow.