Apart from the monitors: what the Google LLM Council does not quite tell you

Author: Mayank Bohr

Originally published in the direction of artificial intelligence.

All right, let's talk about fast engineering. Every second week, it seems that there is a new set of secrets or magical techniques that guarantee unlocking AI perfection. Recently, the official document from Google took round, presenting their approach to obtaining better results from large language models.

Look, effective monitors are absolutely necessary. This is the interface layer, how we convey our intentions with this incredibly powerful, but often frustrating opaque models. Think about how to give instructions a brilliant, but somewhat eccentric younger engineer who only understands natural language. You must be bright, specific and provide context.

But let's be pragmatic. The idea that a few quick corrections have magically “10x” your results for each task is a marketing noise, not an engineering reality. These models, for all their abilities, are basically machines that match patterns operating in the probabilistic space. They don't understand like a man. Signing consists in poking this pattern tailored to the desired result.

So what included Google's advice and what is the builder's experience? Techniques generally come down to the principles that we have known for some time: brightness, structure, giving examples and iterations.

Basics: brightness, structure, context

A significant part of the tips focus on the fact that your intentions are unambiguous. This is zero zero to deal with LLMS. Below they find patterns in huge amounts of data, but they will come across ambiguity.

• Being specific and detailed: This is not a secret; It's just good communication. If you ask for “information about AI”, you will receive something general. If you ask for “a summary of recent progress in the generative architecture of AI models published in research articles since April 2025, focusing on MOO models”, you give the model a much better goal.
• Defining the starting format: Models are flexible text generators. If you do not specify the structure (JSON, Bullet Points, a specific paragraph format), you will receive all statistically likely data based on training data, which is often inconsistent. Saying the model “Answer in JSON format using the” Summary “and” Key_Findings “keys is not magic; Set clear requirements.
• Providing context: The models have limited contextual windows. Showing the entire code database or the entire user documentation will not work. You must exhaust important information. This principle is the entire basis for recovering the extended generation (RAG), in which you recover appropriate data fragments, and then give them as a context. Speech alone without proper external knowledge is used by the internal training data of the model, which may be outdated or insufficient for the tasks specific to the domain.

These points are fundamental. They approach the discovery of hidden model behavior, and more about alleviating the integral ambiguity of the natural language and the lack of true understanding of the world.

Construction of the conversation: roles and limiters

Assigning a role (“act as an expert historian …”) or using restrictions (such as “` `or – -) are simple but effective ways to manage the behavior of the model and separate instructions from the input data.

• Assigning the role: It is a trick for a model for generating a text in accordance with a certain personality or the domain of knowledge he learned during training. He uses the fact that the model has seen countless examples of different writing styles and knowledge expressions. It works, but it is heuristics, not a guarantee of actual accuracy or perfect compliance with this role.
• Using restrictions: Necessary for program hints. When building an application that transmits the user's input data into a line, you must use restrictions (e.g. Triple Backticks, XML tags) to clearly separate the potentially malicious input data of the user from the system instructions. It is a critical safety agent for fast injection attacks, not just a formatting tip.

Distribution of the model's reasoning: a few shots and step by step

Some techniques go beyond the entrance structure; They try to influence the internal processing of the model.

• Few shots: Providing several examples of input/output pairs (“input x → exit y”, entrance a → exit B, input C →? '), If it is often much more effective than describing the task. Why? Because the model learns the desired mapping from examples. This is again recognizing patterns. It is powerful for teaching specific formats or interpretations of numerical instructions that are difficult to describe purely orally. It's basically learning in context.
• Breaking complex tasks: Asking the model for thinking step by step (or implementing techniques, such as a chain of thinking or displaying hints outside the model) encourages him to display medium steps. This often leads to more accurate final results, especially in the case of reasoning tasks. Why? He imitates people, solves problems and forces the model to sequential allocation of computing steps. It is not about secret instructions, but more about conducting the model through a multi -stage process, and not expect that it will start to jump over the answer.

Engineering angle: testing and iteration

The advice also includes testing and iteration. Again, this is not unique for fast engineering. This is fundamental for all software development.

• Test and itej: You write a prompt, test it using various input data, see where you fail or are not optimal, you adjust the prompt and test again. This loop is a reality of building anything reliable in LLM. He emphasizes that the hint is often empirical; You are wondering what works by trying it. This is the opposite of the predictable, documented API interface.

Difficult truth: where fast engineering hits the wall

A pragmatic view really begins here. Fast engineering, although crucial, has significant restrictions, especially in the case of solid applications with production:

1. Context window limits: There is only so much information that you can push into the hint. Long documents, complex stories or large data sets are available. That is why RAG systems are necessary – they dynamically manage the appropriate context. Principle itself does not solve the bottleneck of knowledge.
2. Actual accuracy and hallucinations: No number of hints can guarantee that the model will not come up with facts or probably will not present disinformation. Signing can sometimes alleviate this, for examples, informing the model so that it only stick to the context (RAG), but it does not solve the problem that the model is a predictor of the text, not the engine of truth.
3. Model attitude and undesirable behavior: Signatures may affect the exit, but they cannot easily replace prejudices imprisoned in training data or prevent the generation of harmful or inappropriate content in an unexpected way. Housewives must be implemented * outside * Fast layer.
4. Complex ceiling: In the case of really complex, multi -stage processes requiring external use of the tool, decision making and dynamic condition, pure hint breaks down. It is the domain of AI agents that use LLM as a controller, but are based on external memory, planning modules and tool interaction to achieve goals. Signing is only one part of the agent loop.
5. Maintenance: Try to manage dozens or hundreds of complex, long -term hints in various functions in a large application. Version? Testing changes? It quickly becomes a nightmare of engineering. Signatures are a code, but often undocumented, uncomfortable code living in the strings.
6. Fast injection: As mentioned in the case of delimiters, enabling external input data (from users, databases, API interfaces) in the hints opens the door to install injection attacks, in which the malicious input captures the model's instructions. Solid applications require disinfection and architectural protection except the only limiting trick.

Nobody tells you in quick articles “Secrets” that the difficulty of non -linearly scale with the required reliability and complexity. Getting a nice demonstration output with a clever hint is one thing. Building a function that consistently works for thousands of users on a variety of input data, and at the same time is safe and maintained? This is a completely different game of football.

A real “secret”? It's just good engineering.

If there is any “secret” to build effective applications with LLM, this is not a quick string. It integrates a model with a well -earned system.

This includes:

• Data pipelines: Obtaining appropriate data to the model (for rags, refinement, etc.).
• Orchestration frames: Using tools such as Langchain, Llamaindex or building custom work flows to sequencing models, use tool and data search.
• Rate: Developing solid methods of quantitative measurement of the LLM output quality outside the eyes. It is difficult.
• Handrails: Implementation of security control, moderation and checking of the input validations * except * the LLM call.
• Failure mechanisms: What happens when the model gives a bad answer or fails? Your application requires grateful degradation.
• Control and testing of the version: Treating hints and surrounding logic with the same rigors as any other production code.

Fast engineering is a critical *skill *, part of the general set of tools. It's like knowing how to write effective SQL queries. Necessary to the database interaction, but this does not mean that you can build a scalable internet application with only SQL. You need application code, infrastructure, frontend, etc.

Wrapping

Therefore, the official and similar Google resources offer valuable best practices in interaction with LLM. They formalize a common approach to communication and use observed model behaviors, such as learning a small shot and step -by -step processing. If you are just starting or using LLM for simple tasks, mastering these techniques will absolutely improve your results.

But if you are a programmer, AI practitioner or a technical founder who wants to build solid, reliable applications powered by LLM, understand: fast engineering is table rates. This is necessary, but far from sufficient. A real challenge, real “secrets”, if you want to call them, lie in the surrounding engineering – data management, orchestration, rating, handrails and hard work on building a system, which takes into account the inseparable unpredictability and limitations of LLM.

Do not focus on finding the perfect fast string. Focus on building a resistant system around it. This is where real progress happens.

Published via AI