LLM Selection and Wishing-Style Programming: A Practical Guide for Engineering Teams

    Choosing the right large language model has become a pressing concern as LLMs work their way into daily development. This article contrasts two development mindsets—loose "wishing-style" prompting versus strict contract-driven engineering—and examines how parameter scale shapes intent understanding, using an exclusive-lock example to show where small models fall short. It then covers balancing model tiers against cost, navigating compliance and data-security constraints in regulated industries, and offers practical recommendations for matching models to tasks, writing clear contracts, controlling costs through layered collaboration, and catching subtle concurrency defects.

    Introduction: The Split in AI-Assisted Programming

    As large language models are pushed further into everyday development workflows, one practical question keeps resurfacing: when the models available to you differ dramatically in parameter scale, how should you choose among them? In practice, two distinct development mindsets have emerged. One is “wishing-style programming”—issuing relatively high-level, even vague, instructions and expecting the model to grasp the goal and just build the thing. The other is closer to formal engineering, requiring the model to strictly follow predefined contracts and constraints and to advance along the developer’s own line of reasoning.

    Neither mindset is inherently superior. But their use cases, cost structures, and approaches to risk control differ entirely. To make a sound trade-off, you first need to understand where large models and small models diverge in their core capabilities.

    1. Intent Understanding: The Fundamental Divide

    In enterprise projects, getting a model to “do the work” is only the surface requirement. The deeper requirement is getting the model to “understand intent”—and this capability gap is exactly what parameter scale creates.

    Small models are positioned as efficient executors. They respond to instructions directly, run fast, and cost less per unit. They fit scenarios with clear task boundaries and well-defined goals. But they carry one notable trait: they demand highly precise prompts. Developers must spell out every boundary condition and every constraint explicitly, leaving no ambiguity. The moment an instruction contains a gray area, a small model tends to implement whatever the most convenient literal reading suggests, rather than inferring the real design intent behind it.

    The value of a large model lies in its ability to infer the developer’s true purpose from context. Even when benchmark scores look comparable, large models usually deliver a better real-world interaction experience—they can “read” the implicit constraints you never stated and therefore drift less, even under vague instructions. This capability, of course, usually comes with a higher cost per call. It explains an often-overlooked fact: the core value of a large model is that it “wishes more accurately,” and the more accurately you wish, the less trial-and-error and rework you consume downstream.

    2. A Trade-off Example: Exclusive Lock Design

    The difference in intent understanding is easier to grasp through a concrete scenario. Suppose you’re building an enterprise archive management system, where archives exist alongside business data. For operational safety, you need to place an exclusive lock on the relevant resources. One detail here is easy to overlook: which layer should the lock sit on?

    Without an explicit instruction, a small model will most likely default to locking the identifier at the “archive folder” layer. Such an implementation passes basic tests and does provide concurrency protection:

    1. # Typical small-model implementation under a vague prompt: locking at the archive folder layer
    2. def update_archive(data_id, archive_id):
    3. with exclusive_lock(archive_id): # lock on the archive folder
    4. archive = load_archive(archive_id)
    5. archive.update()

    But the developer’s actual design intent is often to lock the business data’s primary key directly, so that the archive operation is made exclusive along with the data:

    1. # Expected design: lock on the data primary key, with the archive made exclusive along with it
    2. def update_data_and_archive(data_id, archive_id):
    3. with exclusive_lock(data_id): # lock on the data primary key
    4. data = load_data(data_id)
    5. archive = load_archive(archive_id)
    6. data.update()
    7. archive.update()

    Both versions “run,” but the difference is significant. The latter design can greatly simplify the code and logic, and more importantly, it eliminates a class of subtle concurrency defects: while the backend is performing a data operation, another user deletes the entire record, leaving the operation dangling or the data inconsistent. Such problems never surface in unit tests, yet they tend to erupt in production under concurrent load. A small model is a capable “worker,” but it does tend to overlook architectural intent—which is exactly where a large model needs to step in.

    3. The Boundary Between Wishing-Style Programming and Formal Engineering

    It’s worth clarifying that the points above don’t contradict wishing-style programming. That approach aims to quickly build a prototype, validate an idea, and speed up iteration—it is highly efficient during early exploration and for one-off scripts. The core demand of a formal project is different: make the model strictly follow all sorts of “peculiar contracts” and advance along the developer’s established line of reasoning.

    The key difference between the two lies in their attitude toward the “optimal solution.” In formal engineering, even when a theoretically superior implementation exists, the team may—after weighing the performance loss—choose to abandon that “better” solution in favor of one that better conforms to existing conventions and is easier for future maintainers to understand. Wishing-style programming rarely considers this trade-off, whereas engineering development must fold it into every decision. So when selecting a model, the question isn’t only “can the model build this?” but also “can the model build it within the constraints I’ve set?”

    4. Balancing Parameter Scale and Cost-Benefit

    From a cost-benefit perspective, model selection calls for a layered collaboration approach rather than relying on a single model to do everything.

    Large models cost more and come with relatively limited quotas, but precisely because they “wish more accurately” and require less trial-and-error, their per-unit output value is higher in requirements gathering, solution design, and troubleshooting hard problems. Small models offer ample quotas and low cost, making them well suited to specific execution tasks that have already been clearly broken down. A pragmatic workflow is to use the large model to clarify intent and break down tasks—slicing complex requirements into clearly bounded details—then hand those details to the small model for batch execution. This preserves the judgment of the high-capability model while exploiting the scale advantage of the low-cost one.

    This also suggests that simply comparing “how far the quota goes” has limited meaning. What truly matters is the total cost per task, including trial-and-error, rework, and human verification. A model that can infer the intent correctly on the first attempt may cost more per call yet come out cheaper overall.

    5. Compliance and Scenario Considerations for Enterprises

    In settings such as government agencies and state-owned enterprises, selection is often governed by hard constraints on compliance and data security, with high demands for keeping data within its region, ensuring a controllable supply chain, and supporting private deployment. Under such requirements, selecting through platform capabilities that can meet compliance obligations—such as the large model services and related support capabilities offered by Baidu AI Cloud—is a realistic path for many teams.

    For concrete implementation, it helps to evaluate across three dimensions. First, whether intent understanding matches business complexity—complex businesses should lean toward large models. Second, whether the cost structure matches call volume—high-frequency execution tasks can bring in small models for layered handling. Third, whether compliance requirements are satisfied—scenarios involving sensitive data should prioritize deployment modes and data governance capabilities.

    6. Practical Recommendations

    Drawing the analysis together, here are the key recommendations for team-level selection and collaboration:

    • Match models to scenarios: Hand ambiguous requirements that need intent inference to large models; hand clearly bounded, batch-executable tasks to small models.
    • Write the contracts clearly: Regardless of which model you use, state key constraints and boundary conditions explicitly to curb the drift that comes from the model filling gaps on its own.
    • Control costs through layered collaboration: Let the large model handle planning and breakdown, and the small model handle execution—balancing quality against budget.
    • Watch for subtle defects: Issues like concurrency and consistency often stay hidden in tests, so architecture-level decisions such as lock granularity and transaction boundaries need human oversight.
    • Put compliance first: For sensitive scenarios, prefer solutions that satisfy data governance and deployment compliance requirements.

    In the end, models are just tools. The essence of selection is a trade-off among intent understanding, engineering controllability, and cost-benefit. Only by understanding the capability boundaries of each parameter scale—and designing collaboration workflows around them—can you both bring ideas to life quickly and preserve the quality and maintainability of formal engineering.