An AI assistant can write code quickly and still waste much of the work by making poor decisions.
It might ask for information that's already available, rerun a command without changing its approach, accept a technically incorrect premise, or claim a task is finished without verifying the result.
These issues aren't always caused by a lack of model capability. They can also stem from how we specify when to decide, when to act, when to ask, and how to validate.
That's why I created ia-sincer, an open-source skill designed to guide AI assistants toward more critical, focused, and evidence-based behavior.
In v1.1.0, I reduced the instruction text by roughly half in both Portuguese and English and reorganized the skill around a concise operational cycle:
Context → Decision → Action → Validation
The most important change, however, isn't simply using fewer words. It's preserving essential decision criteria in a smaller, clearer specification that's easier to apply during execution.
In this article, I'll explain what changed, why I made these choices, and which results can already be verified—without confusing fewer instructions with performance improvements that haven't been measured yet.
The problem: more instructions don't necessarily lead to better decisions
A skill usually starts small. An edge case appears, so we add a rule. An answer goes wrong, so we add an example. A tool fails, so we add an exception.
Over time, the documentation can turn into a collection of partially redundant recommendations.
That creates several risks:
- More context consumed: rules and examples take up space that could be used for code, logs, diffs, and tool results.
- Competing instructions: similar guidance expressed in different ways can introduce ambiguity.
- Ritualized behavior: agents may follow steps out of habit even when those steps aren't needed.
- More friction during execution: questions and retries can interrupt work even when enough context is available to proceed.
This doesn't mean every long prompt is bad. Additional instructions can be essential for complex tasks. The problem is text that doesn't change a decision, reduce a meaningful risk, or help verify the outcome.
That was my guiding criterion when revising ia-sincer.
1. What changed in v1.1.0
The v1.1.0 changelog documents a substantial reduction in the size of both language versions:
| Language | Before | v1.1.0 | Approx. reduction |
|---|---|---|---|
| Portuguese | 2,056 words | 1,016 words | 50.6% |
| English | 2,065 words | 1,010 words | 51.1% |
These figures are word counts, not benchmarks of token usage, speed, or cost. Actual token counts depend on the tokenizer, the model, and how the instructions are included in context.
The shorter version preserves the core safeguards while introducing improvements in other areas:
- Context and evidence hierarchy, including instructions, memory, and retrieved data.
- Criteria for deciding when to ask a question and when to proceed with a reasonable assumption.
- Handling tool failures without blindly repeating the same operation.
- Risk-proportionate validation and clear reporting of the task's actual state.
- Optional RTK integration, without making it a dependency or a trigger for invoking the skill.
- Automated checks for frontmatter, a 1,200-word limit, and size parity between Portuguese and English.
- Benchmark artifacts and a reproducible v1.0.1 reference report.
The goal is to make the skill more operational and less encyclopedic.
2. A short cycle: context → decision → action → validation
Version 1.1.0 organizes behavior around four conceptual steps:
Context ──→ Decision ──→ Action ──→ Validation
↑ │
└──────── new evidence / error ─────┘
This isn't a rigid checklist that forces the agent to narrate every step. It's a way to identify the next useful action.
Context: what actually matters right now?
The agent should consider the request, constraints, verified project state, and tool evidence. It doesn't need to load or repeat irrelevant information just because it's available.
Decision: is there enough information to move forward?
When the criteria are sufficient, the skill favors a supported recommendation over an endless list of alternatives. If a missing detail could materially change the action or its risk, asking makes sense. Otherwise, a reasonable assumption—stated briefly when relevant—may be better than interrupting the work.
Action: what's the necessary next step?
Act within the authorized scope, choose tools based on what needs to be established, and avoid redundant operations. A failure should lead to a better hypothesis, not an identical retry.
Validation: what has actually been verified?
The final response should distinguish completed, partial, blocked, and not verified. This helps prevent a code change from being presented as a fix that has already passed testing.
3. A practical example: fewer blind retries, more evidence
Consider this request to a coding agent:
"The API started returning errors after a change. Investigate and fix it."
A poorly disciplined workflow might rerun the same test several times, propose multiple solutions before investigating the cause, or announce a fix simply because a file was edited.
A workflow guided by ia-sincer's principles should look more like this:
1. Inspect the error and the relevant change.
2. Form a hypothesis supported by logs or tests.
3. Choose the smallest fix that meets the requirements.
4. Apply the authorized change.
5. Run a check that exercises the affected behavior.
6. Report what passed, what failed, and what wasn't tested.
If the test still fails, the agent should use the new error to revisit its hypothesis before trying again.
Important: this is an illustration of the intended behavior, not the result of a comparative experiment. The skill guides decisions; it doesn't guarantee that every model or task will follow this flow perfectly.
4. Active honesty isn't rudeness—it's refusing to validate false premises
One of the original motivations behind ia-sincer was to address the tendency of some assistants to automatically agree with the person asking for help.
In engineering, agreement without evidence can be costly. A poor architectural decision doesn't become correct just because the request was written confidently.
In v1.1.0, this principle became more precise:
- Verifiably false premise: identify the problem, show the evidence, and propose a correction.
- Legitimate preference: respect the user's choices and constraints, even when another option is possible.
- Insufficient evidence: state the uncertainty instead of inventing confidence or forcing a winner.
- Relevant new information: update the recommendation because the facts changed, not because someone insisted.
Useful honesty isn't about being aggressive. It's about keeping the tone of a conversation from replacing technical criteria.
5. Evidence hierarchy: not all context deserves equal weight
Agents receive instructions, conversation history, memory, files, search results, and tool outputs. These sources can conflict.
ia-sincer now provides guidance for resolving conflicts based on instruction authority and evidence applicable to the current environment, rather than treating every piece of information as equivalent.
For example, suppose conversation memory says a project uses an older dependency, but the current repository manifest shows a newer version. The verified project state should inform the technical decision.
This doesn't authorize ignoring higher-priority instructions, exceeding permissions, or treating retrieved data as commands. Useful context and authorization are different things.
The principle is simple: newer information isn't automatically more reliable, and a convincing statement isn't automatically true.
6. RTK: a complementary optimization, not a dependency
Version 1.1.0 also distinguishes two kinds of noise:
| Layer | Problem | Role of the solution |
|---|---|---|
| Prompts and responses | Redundancy, indecision, excessive communication | ia-sincer guides judgment and communication. |
| Command output | Long logs and low-value information | RTK can filter output from compatible commands. |
The installer can detect RTK and offer to install it. Explicit options are also available to install it or skip that step.
The key point is that RTK isn't required to use the skill. And if filtered output hides evidence needed for debugging, the original output should be inspected.
The tools operate at different layers and can complement each other. Any actual savings in tokens or time, however, need to be measured in the specific environment and tasks being run.
7. What's verified—and what still needs benchmarking
There's an important difference between improving the design of a skill and proving a productivity gain for an agent.
With v1.1.0, I can point to changes that are verifiable in the repository:
- The skill text is approximately 50% shorter in both languages, measured in words.
- Its rules have been reorganized around context, decisions, execution, and validation.
- Automated checks for structure and context budget have been added.
- RTK remains an optional optimization.
What doesn't automatically follow from these facts is a claim such as "the AI became 50% faster" or "costs were cut in half."
To evaluate those outcomes properly, I plan to compare versions on equivalent tasks while controlling for the model and execution conditions, using metrics such as:
| Metric | Why it matters |
|---|---|
| Input and output tokens | Measures actual context and response consumption. |
| Total time to completion | Captures end-to-end task latency, not just a single message. |
| Tool calls | Helps identify unnecessary lookups and retries. |
| Rework count | Shows how many additional corrections were needed. |
| Validated completion rate | Checks whether the task was truly solved. |
| Errors or regressions | Avoids trading quality for shorter responses. |
The changelog lists CargaLeste benchmark artifacts and a reproducible v1.0.1 reference report. This provides a foundation for future comparisons, but isn't, by itself, published evidence that v1.1.0 outperforms v1.0.1.
I want to measure not just whether the AI says less, but whether it reaches correct results with fewer unproductive iterations.
8. How to try ia-sincer
The project is open source and supports installation through NPX, with Node/Bash and manual installation options as well.
To launch the interactive installer:
npx ia-sincer
For commands that target a specific compatible assistant, see the up-to-date instructions in the project README.
The skill is available in Portuguese and English:
To evaluate the difference in your own environment, choose real tasks and compare behavior with and without the skill, paying attention to both decision quality and validated outcomes.
Conclusion: a better skill isn't just a smaller skill
The evolution of ia-sincer to v1.1.0 reinforces a principle that has guided the project: productivity in agentic workflows depends on decisions as much as on code generation.
An instruction is useful when it helps an agent recognize relevant context, correct a false premise, choose the next action, or verify a result. If it merely repeats something that's already clear, it may not need to be there.
Version 1.1.0 takes a concrete step in that direction: less text, more concentrated rules, and more explicit criteria for execution and validation.
There's still work to do to measure its impact across different models and tasks. And separating what was implemented from what was proven in execution is part of ia-sincer's own philosophy.
Repository: github.com/inclitoleo/ia-sincer
Top comments (0)