At GooApps®, 2025 was the year we stopped “experimenting with AI” and started working with generative AI deliberately. We invested more than 1,000 hours in internal training, research, and development to learn how to apply AI in a way that is useful, verifiable, and responsible—avoiding both hype and risky shortcuts.
This learning did not remain theoretical. It allowed us to define real best practices for using generative AI, both in daily work and in software development environments, with a clear objective: accelerate without losing control, judgment, or accountability.
This article summarizes that learning across two complementary dimensions: everyday use of generative AI and its practical application in development workflows.
Generative AI is extremely powerful. Precisely because of that, it must be used methodically. In our experience, the most common issues do not come from “AI failing,” but from recurring misuse patterns:
During GooApps® internal training, the conclusion was clear: if we cannot explain the result, test it, and take responsibility for it, then it is not progress—it is risk. This principle guides all our generative AI practices.
One of the most impactful practices we adopted is asking AI itself to help us build robust, reusable prompts instead of improvising each time.
This transforms generative AI usage: instead of testing prompts on the fly, we work with well-defined, consistent, and reusable briefs. The result is a significant improvement in output quality and stability.
This approach turns the prompt into a work artifact in its own right, not just an input text.
Act as an expert in prompt engineering.Design a robust PROMPT for the following task:[TASK]Before writing the final prompt:Ask me all necessary questions to remove ambiguities (minimum 8).Propose two variants of the prompt:
(A) a brief version
(B) a comprehensive versionInclude a section of constraints and another of quality criteria.Include an example input and an example output.When finished, deliver only the final prompt (version B), ready to copy and paste.
Task: summarize a meeting and generate next steps.
Result: a prompt that forces the model to request context (objective, audience, tone, decisions made, owners) and produces an actionable summary in a standardized, reusable format.
One of the most effective practices we systematically apply is forcing the model to detect ambiguities and request context before executing the task.
Explicit instructions such as “ask me your questions before acting” push AI to surface assumptions, detect information gaps, and avoid invented responses. The quality difference compared to a direct prompt is immediate and measurable.
Before executing the task:Ask me all the questions you need to do it properly.If information is missing, do not invent it. Explain what is missing and why.Once you have sufficient context, execute the task step by step.
Task: draft a proposal for a client using AI.
Without this instruction, results are typically generic.
With it, the model asks about sector, objective, scope, risks, timeline, and differentiators—significantly elevating the final quality.
When working recurrently with generative AI, structure matters as much as content. A structured prompt based on context, objective, scope, constraints, examples, and quality criteria produces consistent results across junior and senior profiles.
CONTEXT
Who you are, what you need, and how the result will be used.
Audience and tone.
OBJECTIVE
What you want to achieve, defined in one clear, measurable sentence.
SCOPE
What is included and what is excluded. Explicit boundaries.
DATA / INPUT
Relevant information, base texts, sources, or links.
CONSTRAINTS
Output format (table, list, email, JSON…).
Approximate length.
Language.
Specific rules (do not invent, cite sources, etc.).
EXAMPLES
Example of good output.
Example of bad output (what to avoid).
QUALITY CRITERIA
Between 3 and 7 checks to validate the result.
QUESTIONS
Before starting, ask me what you need.
This structure reduces errors, simplifies validation, and turns AI interaction into a controlled process rather than an improvised conversation.
At GooApps®, we use different generative AI models depending on the task. There is no universally superior model: performance depends on task type, context constraints, cost, latency, and—most importantly—how the prompt is structured.
For ideation, documentation, and synthesis tasks, models with strong structuring and instruction-following capabilities perform best. For coding, refactoring, and debugging tasks, the differentiating factor is the model’s ability to understand context and maintain coherence within a real codebase.
| Task | Recommended Model | Why We Choose It |
|---|---|---|
| Refactoring & Complex Code | Claude 3.7 (Anthropic) | Superior extended reasoning and long-context handling for legacy architectures. |
| Ideation & Documentation | GPT-4.1 (OpenAI) | Excellent instruction following and structured output consistency. |
| Multimodal Reasoning | Gemini 2.5 Pro (Google) | Strong at analyzing video and large multimodal datasets in a single context window. |
For ideation and synthesis:
For coding, refactoring, and debugging:
For tool-based workflows, agents, and connectors:
The decisive factor is not raw intelligence, but available context and permissions. This is where MCPs become critical.
In daily development, at GooApps® we work with copilots integrated into IDEs such as JetBrains, VS Code, or Cursor, depending on the project. The objective is not to let AI write unsupervised code, but to integrate it into a reliable workflow.
Our internal rule is clear: if the copilot generates code, it must meet the same standards as a human developer. Architectural coherence, repository style compliance, correct error handling, tests, and review are mandatory.
For coding tasks, we explicitly request change plans, file-level diffs, minimum unit tests, and risk lists. This turns AI into a development assistant—not a blind code generator.
If the copilot generates code, we require:
I need a refactor to separate validation logic from the controller.Provide:- A change plan
- A file-by-file diff
- Minimum unit tests
- A list of technical risks
The Model Context Protocol (MCP) is an open standard designed to connect generative AI assistants to systems where real context lives: repositories, documentation, business tools, or design environments.
In practice, MCPs allow AI to access internal documentation, tickets, specifications, or designs—reducing hallucinations and increasing response relevance.
At GooApps®, MCPs reduce the “telephone game” between requirements, design, and implementation. Context no longer depends on individual memory; it becomes accessible, traceable, and verifiable.
Connecting AI to internal systems amplifies both value and risk. We therefore apply clear principles: least privilege, access control, audit logging, and careful review of third-party integrations.
This approach aligns with our vision of AI that is understandable, verifiable, and responsible—even when deeply integrated into development workflows.
This learning is not an internal curiosity. It directly impacts how we deliver products: clearer feature definition, greater speed with control, reinforced QA, and more traceable decisions.
We use generative AI to increase focus and quality—not to produce text or code without thinking.
The most important practice we extracted from 2025 is simple: make AI work like a good senior developer. Make it ask questions, surface assumptions, propose options, and deliver verifiable results.
Generative AI is not magic. Used well, it is a powerful competitive advantage. Used poorly, it becomes technical and product debt. That is why at GooApps® we chose to train and apply AI from within—with judgment.
Complete the form and GooApps® will help you find the best solution for your organization. We will contact you very soon!
+34 656 828 020
Schedule an online meeting 