Rethinking LLM Scaling Laws: How Far Can Post-Training Actually Go?

    Does adding more parameters always make a large language model stronger? Not exactly. This article reframes Scaling Laws as a multi-variable optimization problem across parameters, data quality, training compute, inference cost, architecture, and post-training. It explains two common industry mistakes, how to read controlled post-training experiments, how to weigh capability against cost and latency using a Pareto frontier, the real limits of chain-of-thought length, whether a 700B-scale model is "enough" for coding tasks, and why high-quality executable environments are becoming the true fuel for code capability. Readers will come away with a practical selection checklist for evaluating LLMs rationally in real business and enterprise settings.

    Start With the Conclusion: Do More Parameters Always Mean a Stronger Model?

    The answer is not a simple “yes.” More precisely, parameter scale is only one of several variables that affect model capability. What actually determines real-world performance is the combined effect of parameters, data quality, training duration, inference cost, model architecture, and post-training strategy.

    If you treat large-model selection as simply “pick the model with the most parameters,” you easily overlook three critical questions: whether the data is sufficient, whether inference costs are sustainable, and whether post-training can steer capabilities toward real tasks. In enterprise deployments especially, a model must not only “answer questions”—it must answer reliably, cheaply, verifiably, and in a way that can be operated at scale.

    Four Questions Developers Ask Most

    • How do you know whether a model is good enough?
      Don’t rely only on public leaderboards. Evaluate accuracy, stability, latency, cost, and failure rate on your own business evaluation set.

    • When should you do post-training?
      When the base model already has foundational capabilities but falls short on instruction following, code, tool calling, domain knowledge, or safety alignment, post-training is usually more cost-effective than blindly switching to a larger model.

    • How do you evaluate inference cost?
      Focus on first-token latency, throughput, GPU memory usage, concurrency, long-context cost, and the total cost of ownership per request.

    • What are the common mistakes?
      Piling on parameters while ignoring high-quality data; watching only training cost while ignoring long-term inference cost; chasing the capability ceiling while neglecting engineering support; and treating long chains of thought as a universal solution.

    What Is Scaling Law Really Optimizing?

    Conventionally, Scaling Laws are simplified to “bigger models are better.” But in real training and deployment, they behave more like a joint, multi-variable optimization problem.

    Variable Impact on model capability What to ask during selection
    Parameter scale Determines potential capacity, but bigger is not always better Does the current task really need more capacity?
    Data quality and quantity Determines breadth of knowledge, language ability, and generalization Does the data cover the target business scenarios?
    Training duration and compute Affects whether the model converges fully Is the training budget sufficient? Is the model undertrained?
    Inference cost Determines whether long-term deployment is economical Are per-request cost, memory, and latency acceptable?
    Model architecture Dense vs. MoE designs affect activated parameters and inference overhead Do you want simpler deployment or better sparse-activation efficiency?
    Post-training and alignment Affects task fit, instruction following, and output quality Do you have a high-quality feedback environment and evaluation system?

    The key point is that these variables are not independent—they constrain one another. Too many parameters but too little data, and the model may be “underfed.” Low training cost but high inference cost, and the model may be “affordable to train but too expensive to run.” A more sensible approach is to understand Scaling Laws as a joint trade-off among scale, data, cost, and engineering.

    Two Mistakes the Industry Often Made Early On

    Mistake One: Building the Model Too Big While Feeding It Too Little Data

    Early on, many teams believed in “throwing more resources at the problem,” prioritizing parameter growth while underestimating the scarcity of high-quality training data. When data supply is insufficient, the returns from adding more parameters drop quickly. The model may look bigger, but its knowledge density, reasoning quality, and task fit do not improve accordingly.

    Mistake Two: Optimizing Only for Training Cost While Ignoring Long-Term Inference Cost

    Training is typically a one-time investment, while inference is a long-term, high-frequency, ongoing expense. If a model is cheap to train but requires large amounts of GPU memory, compute, or long-context processing on every request after launch, its total cost of ownership can far exceed expectations.

    This is also why more and more teams are paying attention to sparse-activation architectures like MoE (Mixture of Experts). By activating only a subset of expert parameters, MoE can potentially lower the compute cost of a single forward pass while keeping the total parameter count high. But note that MoE also introduces complexity in GPU memory management, routing balance, service deployment, and inference scheduling—it is not a simple drop-in replacement that solves everything.

    How Far Can Post-Training Go: How Should You Read Controlled Experiments?

    A noteworthy phenomenon is this: with the base model, network architecture, total parameter count, and activated parameter count all held constant, a period of post-training and reinforcement learning can noticeably improve a model’s performance on specific tasks.

    It is important to stress that such conclusions cannot be detached from experimental conditions. A more accurate interpretation is this: in a controlled experiment where the source is the team’s public retrospective and evaluation records; where the base model version is the same snapshot of the same foundation model; where the evaluation uses the same prompts, the same public evaluation sets, the same scorer, and the same time window; and where the baselines are the original base model and contemporaneous models of the same parameter scale—the post-trained version may reach comparable results on specific evaluation sets, rather than unconditionally surpassing all competitors.

    1. # Illustrative pseudocode: shows only the post-training loop, not a complete runnable implementation.
    2. # A real implementation must specify the RL algorithm (e.g., PPO, DPO, GRPO),
    3. # the reward function, reward normalization, KL or length constraints,
    4. # and anti-reward-hacking evaluation.
    5. def post_training_step(base_model, prompt_batch, reward_fn):
    6. responses = base_model.generate(prompt_batch)
    7. rewards = reward_fn(prompt_batch, responses) # e.g., whether the code passes tests
    8. loss = compute_policy_loss(base_model, prompt_batch, responses, rewards)
    9. loss.backward() # update post-training-related parameters
    10. return base_model

    The value of post-training is that it usually does not require modifying the base model; instead, it targets specific capabilities for optimization—for example, code completion, unit test fixing, instruction following, tool calling, or safety alignment. If the pretrained base is already strong enough but some capabilities have not been fully activated, post-training can offer a very high return on investment.

    That said, post-training is not without cost. Common pitfalls include reward hacking, training data leakage, length bias, evaluation saturation, and overfitting to public leaderboards. Ways to mitigate them include: using independent evaluation sets, adding manual spot checks, applying length penalties, introducing process rewards, normalizing the reward function, and establishing continuous regression evaluation.

    The Pareto Frontier: How to Balance Capability, Cost, and Latency?

    When you place “capability” and “cost” on the same chart, you get a Pareto frontier: at each cost tier, the model with the strongest capability. For business selection, what really matters is not chasing the tier with the highest capability ceiling, but finding the point that best matches your own scenario.

    Business scenario Key metrics Selection guidance
    Hard reasoning tasks Accuracy, chain-of-thought stability, error recovery Prioritize the capability ceiling, but verify latency and cost
    High-concurrency online services Throughput, first-token latency, GPU memory, concurrency Prefer models with controllable inference cost
    Code generation and unit test fixing Executable feedback, test pass rate, cost per feedback Focus on the quality of the executable environment and the feedback loop
    Government and enterprise compliance Permission isolation, auditing, on-premises deployment, compliant delivery Don’t look only at leaderboards; look at engineering and service capability
    Cost-sensitive scenarios Cost per request, cache hit rate, batch processing Choose the better price-performance point on the Pareto frontier

    A model that can be cheaper at the same capability level, or stronger at the same cost level, is highly valuable in production. But note that “stronger” must rest on reproducible evaluation and business acceptance, not just a single leaderboard score.

    Chain-of-Thought Length: Trading Time for Space, With Limits

    In practice, some newly released code-oriented models have not significantly lengthened their chains of thought, keeping thinking time relatively restrained. This suggests that longer chains of thought are not always better—they are more like a resource trade-off: a short chain of thought means more direct single-pass inference, while a long chain of thought means trading more generation steps for higher reasoning quality.

    1. # Illustration: a long chain of thought is equivalent to approximating "deeper thinking"
    2. # through more rounds of forward computation
    3. def reasoning_loop(model, question, max_steps):
    4. context = question
    5. for step in range(max_steps):
    6. block = model.generate(context) # one forward pass
    7. context += block # write intermediate results back into the context
    8. if has_reached_answer(context):
    9. break
    10. return context

    Smaller models sometimes need to rely on longer chains of thought to compensate for limited capacity, because a single forward pass of a Transformer can only perform a limited amount of computation. Each time the model generates a reasoning step, it writes the intermediate result back into the context and continues computing. This is similar to breaking a problem into more steps and progressively approaching the answer.

    But long chains of thought also have limits. They bring higher latency, higher token costs, and a greater risk of overthinking. In simple tasks especially, if the model repeatedly self-verifies without converging, it wastes inference budget. Therefore, judging whether a model is suitable cannot depend only on “whether it thinks for a long time”—it depends on whether it can reliably produce correct results within acceptable costs.

    Code Tasks: Is 700B Scale Enough?

    For tasks like writing code, you cannot simply conclude that “700B parameter scale is definitely enough.” A more reasonable statement is: for specific tasks such as code completion and unit test fixing, in specific programming languages and on specific evaluation sets, a 700B-scale model may meet most business needs. But whether it is ultimately sufficient still needs to be validated against latency, GPU memory, throughput, the feedback environment, and the cost of failures.

    Evaluation dimension Questions to confirm
    Task type Is it code completion, unit test fixing, code explanation, or complex refactoring?
    Evaluation set Does it come from real business code, rather than a single public leaderboard?
    Latency requirement Can users accept second-level responses, or is millisecond-level required?
    GPU memory and concurrency How many concurrent requests can the current hardware support?
    Feedback environment Is there executable feedback such as compilation, execution, and unit tests?

    What makes code tasks special is that they usually have a “verifiable, executable” feedback loop. If code generated by the model can pass compilation, run, and pass unit tests, it can obtain a relatively clear reward signal. This feedback loop is important fuel for improving code capability through post-training and reinforcement learning.

    High-Quality Executable Environments: The Real Fuel for Code Capability

    Once parameter scale reaches a certain level, further improvements in code capability often depend not just on parameters but on the throughput of high-quality executable environments. An executable environment is a sandbox or evaluation system where a model can actually run code, get feedback, and receive signals for improvement.

    A high-quality executable environment should focus on the following metrics:

    • Sandbox isolation: Ensure code execution is safe and does not affect the host environment.
    • Test coverage: Do test cases cover normal paths, boundary conditions, and abnormal inputs?
    • Feedback latency: Can compilation, execution, and test results be returned quickly?
    • Cost per feedback: How much compute or cost does each execution and evaluation consume?
    • Failure sample reflow: Can failure cases be collected, cleaned, and reused for later training or evaluation?

    Without high-quality feedback, a model can only rely on pattern imitation from its corpus and struggles to break through its capability ceiling. Conversely, if the feedback environment is good enough, even a model that is not the largest in parameter scale can achieve stronger task performance through continuous post-training.

    Security Capabilities for Government and Enterprise: Focus Only on Defense and Compliant Delivery

    In recent years, some teams have begun treating cybersecurity capability as one of their key directions. Here, “security capability” should be limited to protection, detection, compliant delivery, and engineering services—it does not involve steps for bypassing security defenses, breaking into systems, or carrying out attacks. Its core value lies in helping enterprises build a more secure model application environment.

    Delivering security capabilities has its own specifics. It is usually not a single-model capability output, but a service system oriented toward government and large-enterprise customers, including requirements analysis, solution design, permission isolation, log auditing, compliant delivery, on-premises deployment, and continuous operations. Whoever builds engineering and service support capabilities first may gain an advantage in the next phase.

    For enterprise selection, this points to an important principle: evaluating a large model cannot rely only on public evaluation scores; you must also consider whether it can be deployed reliably in real businesses with high compliance and high security requirements, and whether it has the supporting engineering, operations, and service capabilities.

    Selection Checklist: How to Rationally Evaluate a Large Model?

    When selecting a model in practice, you can refer to the following checklist:

    1. Capability dimension

      • Does it reach an acceptable accuracy on your target business evaluation set?
      • Does it distinguish capabilities that are certain, possible, and scenario-dependent?
      • Does it output stably on real tasks, rather than only being good for demos?
    2. Cost dimension

      • Is training cost affordable?
      • Can inference cost scale?
      • Do GPU memory, throughput, latency, and concurrency meet business peaks?
    3. Data and post-training dimension

      • Do you have high-quality business data that can reflow and be cleaned?
      • Does post-training have a clear goal, rather than blind alignment?
      • Have you built mechanisms to prevent reward hacking and data leakage, plus independent evaluation?
    4. Engineering and compliance dimension

      • Does it support on-premises deployment, permission control, audit logs, and security isolation?
      • Does it have stable operations, monitoring, and failure recovery?
      • Does it meet the compliant delivery requirements of government and enterprise customers?
    5. Long-term evolution dimension

      • Can model versions be updated continuously?
      • Can the evaluation system be iterated continuously?
      • Can capability boundaries be dynamically adjusted as tasks change?

    Conclusion: The Triangle Balance of Capability, Cost, and Engineering

    Back to the original question: does more parameters always mean a stronger model? The answer is no. Model capability is a joint optimization problem determined together by scale, data, training duration, inference cost, architecture, and post-training.

    Post-training and reinforcement learning can unlock considerable potential on a fixed base model, but their effectiveness depends on evaluation methodology, reward design, and feedback quality. Chain-of-thought length reveals the “trade time for space” logic, but it cannot replace the model’s single-pass reasoning quality itself. On verifiable tasks such as code, the throughput of high-quality executable environments is becoming a more critical competitive variable than parameter scale alone.

    For enterprises and developers, a rational selection framework is not about chasing a single metric, but about finding balance among capability, cost, and engineering support: look at both the capability ceiling and long-term inference cost; look at both public evaluations and real business deployment; and pay attention to both model scale and post-training, the feedback environment, and compliant delivery. That is the way large-model selection should truly be done.