Introducción

Usar IA para generar una función o explicar un error ya es algo habitual. Usarla como parte de un proceso de desarrollo estructurado, reutilizable y verificable es un reto distinto.

Este artículo es una guía práctica sobre esa segunda idea. Explica los bloques principales del desarrollo agéntico en Claude Code (Skills, subagentes, permisos, hooks y MCP) y muestra cómo se conectan con dos capacidades de Power Platform:

  • Power Apps code apps, que permiten crear aplicaciones web personalizadas con herramientas code-first y ejecutarlas en Power Platform.
  • Flujos de nube de Power Automate, que una code app puede invocar como backend.

El objetivo es educativo. Cada afirmación técnica se apoya en documentación oficial, listada en las referencias al final, porque estas herramientas cambian rápido y conviene revisar siempre la documentación vigente antes de depender de un detalle.


De los prompts a los sistemas agénticos

Una forma común de usar IA sigue un patrón sencillo: escribir un prompt, leer la respuesta, ajustar y repetir.

El desarrollo de software normalmente necesita más que eso. Hay que comprender requerimientos, explorar código existente, modificar archivos, ejecutar herramientas, validar resultados, revisar seguridad, probar escenarios y documentar decisiones.

Anthropic describe los sistemas agénticos como una familia con una distinción arquitectónica importante (Anthropic, 2024):

  • Los workflows son sistemas donde los LLM y las herramientas se orquestan mediante rutas de código predefinidas.
  • Los agentes son sistemas donde el LLM dirige dinámicamente su propio proceso y el uso de herramientas.

El mismo artículo incluye una recomendación que vale la pena recordar: buscar la solución más simple posible y aumentar la complejidad solo cuando sea necesario, lo que a veces significa no construir un sistema agéntico (Anthropic, 2024). A veces un buen prompt es suficiente. A veces un workflow fijo es mejor. Los agentes tienen sentido para problemas abiertos donde es difícil predecir el número de pasos.

Qué diferencia a un agente de un chatbot

Un chatbot trabaja alrededor de una conversación. Un agente de desarrollo además puede actuar sobre su entorno. Según las herramientas y permisos que tenga, puede leer archivos, buscar en un repositorio, editar código, ejecutar comandos, compilar un proyecto y correr pruebas.

El cambio importante es el ciclo entre razonamiento, acciones y retroalimentación real. Anthropic señala que durante la ejecución es crucial que los agentes obtengan “ground truth” del entorno en cada paso, como resultados de herramientas o ejecución de código, y que pueden pausar para recibir retroalimentación humana en puntos de control o cuando se bloquean (Anthropic, 2024).

Objetivo
  ↓
Analizar contexto
  ↓
Elegir una acción
  ↓
Usar una herramienta
  ↓
Observar el resultado real
  ↓
¿Se cumplió el objetivo?
  ├── No → ajustar y repetir
  └── Sí → presentar resultado para revisión humana

Ese ciclo es poderoso y también es de donde viene el riesgo. Un agente que puede actuar necesita permisos, límites, verificación y supervisión humana. La misma fuente advierte que la autonomía implica mayores costos y la posibilidad de errores que se acumulan, y recomienda pruebas extensas en entornos aislados con las salvaguardas adecuadas (Anthropic, 2024).


Los bloques de construcción en Claude Code

Claude Code es la herramienta agéntica de Anthropic para desarrollo de software. Además del modelo, ofrece varios mecanismos de extensión. Resuelven problemas distintos y confundirlos es una fuente frecuente de errores (Anthropic, n.d.-a; Anthropic, n.d.-b).

ElementoObjetivo principal
PromptUna instrucción puntual
CLAUDE.mdContexto persistente y convenciones del proyecto
SkillConocimiento o procedimiento reutilizable, cargado cuando es relevante
SubagenteTrabajo especializado en un contexto separado con sus propias herramientas
HooksComandos que se ejecutan automáticamente en eventos del ciclo de uso
Servidor MCPDa al agente acceso a herramientas y servicios externos
PluginPaquete que distribuye skills, agentes, hooks y servidores MCP
Permisos y sandboxingLímites técnicos sobre lo que el agente realmente puede hacer

Dos de ellos merecen un vistazo más detallado.


Skills: de prompts repetidos a procedimientos reutilizables

Si sigues pegando las mismas instrucciones, la misma lista de verificación o el mismo procedimiento de varios pasos en un chat, es un buen candidato para un Skill (Anthropic, n.d.-b).

Un Skill es un directorio con un archivo SKILL.md. El archivo tiene frontmatter YAML que indica a Claude cuándo usarlo, seguido de instrucciones en Markdown. El directorio también puede incluir archivos de apoyo, como documentos de referencia y scripts (Anthropic, n.d.-b).

.claude/
└── skills/
    └── mi-skill/
        ├── SKILL.md          ← obligatorio: resumen e instrucciones
        ├── reference.md      ← documentación detallada, se carga solo si hace falta
        └── scripts/
            └── helper.*      ← script de apoyo, se ejecuta en lugar de cargarse

Algunas propiedades de la documentación oficial importan en la práctica (Anthropic, n.d.-b):

  • La carga es progresiva. Las descripciones de los Skills están en contexto para que Claude sepa qué hay disponible, pero el contenido completo se carga solo cuando se invoca el Skill. El material de referencia extenso casi no cuesta nada hasta que se necesita.
  • Mantén SKILL.md enfocado. La documentación recomienda mantenerlo por debajo de 500 líneas y mover los detalles a archivos separados.
  • La description es lo que lo activa. Claude la usa para decidir cuándo aplicar el Skill, así que debe decir qué hace y cuándo usarlo.
  • La invocación puede restringirse. disable-model-invocation: true evita que Claude ejecute un Skill por su cuenta. La documentación lo recomienda para flujos con efectos secundarios, como los despliegues.
  • El alcance varía. Los skills personales viven en ~/.claude/skills/, los de proyecto en .claude/skills/ (haz commit para que el equipo los comparta) y los plugins permiten distribuirlos más ampliamente.
  • Los Skills siguen un estándar abierto. Los skills de Claude Code siguen el estándar Agent Skills y lo extienden con funciones como el control de invocación y la ejecución en subagentes.

Un Skill no sustituye a la ingeniería

Un Skill genera consistencia. Recuerda al agente qué revisar, qué procedimiento seguir y qué referencias consultar. No garantiza un resultado correcto. El modelo todavía puede interpretar mal un requerimiento o producir código con defectos, por lo que la revisión de arquitectura, la revisión de código y las pruebas siguen siendo necesarias.

La documentación también traza una línea útil: si una regla debe cumplirse siempre, ponla en un hook en lugar de confiar en que Claude siga aplicando una guía escrita (Anthropic, n.d.-b).


Subagentes: separar responsabilidades

Un subagente es un asistente especializado que se ejecuta en su propia ventana de contexto, con su propio prompt de sistema, acceso a herramientas y permisos. Solo devuelve un resumen a la conversación principal (Anthropic, n.d.-a).

Los subagentes son archivos Markdown con frontmatter YAML. Solo name y description son obligatorios. Otros campos útiles son tools (lista de permitidas), disallowedTools, model, skills (para precargar Skills), permissionMode y hooks (Anthropic, n.d.-a).

---
name: code-reviewer
description: Reviews code for quality and best practices
tools: Read, Glob, Grep
model: sonnet
---

You are a code reviewer. When invoked, analyze the code and provide
specific, actionable feedback on quality, security, and best practices.

La guía oficial sobre cuándo usarlos es clara (Anthropic, n.d.-a):

  • Usa subagentes cuando una tarea produce salida voluminosa que no necesitas en el contexto principal, cuando quieres imponer restricciones específicas de herramientas o cuando el trabajo es autocontenido y puede devolver un resumen.
  • Quédate en la conversación principal cuando la tarea requiere mucho ida y vuelta, cuando varias fases comparten mucho contexto o para cambios rápidos y puntuales.

Hay detalles que conviene conocer:

  • Un subagente comienza con un contexto nuevo. No ve tu historial de conversación, solo su propio prompt de sistema, el mensaje de la tarea y el contexto del proyecto, como CLAUDE.md.
  • Cada subagente envía sus propias solicitudes, que cuentan para los mismos límites de uso que la conversación principal.
  • Las descripciones deben ser específicas para que Claude delegue en el subagente correcto. Mantén breve el conjunto de descripciones, porque consumen contexto.

Skills y subagentes no son lo mismo

SkillSubagente
Qué esInstrucciones y conocimiento reutilizablesUn worker especializado
Dónde se ejecutaNormalmente en el contexto de la conversación principalEn un contexto separado y aislado
Uso típicoConvenciones, checklists, recetas paso a pasoRevisiones, ejecución de pruebas, investigación, salida voluminosa
CombinaciónUn Skill puede ejecutarse en un subagente (context: fork)Un subagente puede precargar Skills con el campo skills

Ambas combinaciones existen y son inversas. Con context: fork escribes la tarea en el Skill y eliges un tipo de agente para ejecutarla. Con el campo skills, el subagente controla el prompt y carga el contenido del Skill como material de referencia (Anthropic, n.d.-b).


Dónde entra Power Platform

Hasta aquí nada es específico de tecnología Microsoft. Power Platform entra como el destino para el que construye el agente.

Power Apps code apps

Microsoft describe las code apps como una forma de llevar capacidades de Power Apps a aplicaciones web personalizadas creadas en un IDE code-first, como Visual Studio Code. Se desarrolla localmente y se ejecuta la misma aplicación en Power Platform (Microsoft, n.d.-a). Entre sus características clave:

  • autenticación y autorización con Microsoft Entra;
  • acceso a orígenes de datos de Power Platform y a más de 1,500 conectores, invocables directamente desde JavaScript;
  • hospedaje de aplicaciones web de línea de negocio dentro de Power Platform;
  • cumplimiento de las políticas de plataforma administrada de tu organización, como límites de uso compartido, Conditional Access y prevención de pérdida de datos (DLP);
  • despliegue y gestión del ciclo de vida (ALM) simplificados.

Arquitectónicamente, una code app es una aplicación de una sola página (SPA). Tres piezas cooperan (Microsoft, n.d.-b):

PiezaRol
Biblioteca cliente @microsoft/power-appsAPIs que invoca tu código, más modelos y servicios generados para cada conector que agregas
power.config.jsonArchivo de metadatos generado por la biblioteca, usado por la CLI y la biblioteca para conexiones y publicación
Power Apps CLI y host de Power AppsLa CLI publica la app compilada; en ejecución, el host gestiona la autenticación del usuario y la carga de la app

El ciclo de desarrollo

Según el quickstart oficial (Microsoft, n.d.-c), el ciclo se ve así:

# 1. Partir de la plantilla de Vite
npx degit github:microsoft/PowerAppsCodeApps/templates/vite my-app
cd my-app

# 2. Instalar la CLI y las dependencias, e inicializar la app
npm install --global @microsoft/power-apps-cli
npm install --global @microsoft/power-apps
npm install
pa app init --display-name "My App" --environment-id <environment-id>

# 3. Ejecutar localmente
pa app run

# 4. Compilar y publicar en Power Apps
npm run build
pa app push

Los prerrequisitos listados en el resumen son un IDE, Node.js (LTS), Git y la Power Apps CLI. Además, un administrador de Power Platform debe habilitar las code apps en el entorno, y los usuarios finales necesitan una licencia Power Apps Premium o alguna de las alternativas que Microsoft enumera, como pago por uso o un App Pass (Microsoft, n.d.-a).

Conoce las limitaciones

La documentación también lista restricciones que conviene revisar antes de elegir code apps. Al momento de escribir, Microsoft indica que las code apps (Microsoft, n.d.-a):

  • no admiten la integración con Git de Power Platform;
  • todavía no admiten Secure Implicit Connections;
  • no usan la restricción de IP de Storage SAS, por lo que las restricciones por IP deben apoyarse en Conditional Access;
  • no son compatibles con Power Apps para Windows;
  • no admiten la función PowerBIIntegration de Power BI ni la integración con formularios de SharePoint.

Esta lista puede cambiar, así que confírmala en la página vigente.

Code apps y canvas apps son herramientas distintas

Canvas AppsCode Apps
Experiencia visual low-codeExperiencia code-first
Power Apps StudioUn IDE como Visual Studio Code
Power FxJavaScript / TypeScript
Controles de Power AppsComponentes y frameworks web
Desarrollo rápido para escenarios comunesMayor control sobre UI y arquitectura
Menor necesidad de código tradicionalRequiere habilidades de desarrollo web

Ninguna reemplaza a la otra. La decisión debe partir de los requerimientos, del equipo que mantendrá la solución, del nivel de personalización necesario y de las capacidades disponibles. Si quieres una comparación más amplia entre tipos de apps, consulta Canvas vs Model-driven.


Flujos de Power Automate como backend de una code app

Una code app puede invocar flujos de nube de Power Automate, lo que permite mantener la lógica de negocio y las integraciones en una capa gobernada y low-code mientras el front end se mantiene en código.

Según la documentación (Microsoft, n.d.-d):

  • Solo se admiten flujos instantáneos con reconocimiento de soluciones que usan el desencadenador de Power Apps. Los flujos programados, los automatizados y los instantáneos con otros desencadenadores no se admiten.
  • Quien agrega el flujo debe tener acceso al flujo y a sus conexiones subyacentes.
  • Los usuarios finales necesitan permisos suficientes en Dataverse para invocarlo, como el rol de seguridad App Opener o uno equivalente.
  • Cuando cambia la definición del flujo, hay que volver a agregarlo para actualizar los archivos generados.

El flujo de trabajo con la CLI es:

pa app list-flows                         # lista flujos con reconocimiento de soluciones
pa app add flow --flow-id <flow-id>       # genera modelos y servicios tipados

La CLI descarga la definición OpenAPI del flujo, genera modelos y servicios TypeScript fuertemente tipados y registra el flujo y sus referencias de conexión en power.config.json. Invocarlo se parece a cualquier otro servicio tipado (Microsoft, n.d.-d):

import { ApprovalWorkflowService } from "./services/ApprovalWorkflowService";

const result = await ApprovalWorkflowService.Run({
  requester: "Alex",
  amount: 1500,
});

if (result.success) {
  console.log("Flow triggered. Response:", result.data);
} else {
  console.error("Flow failed:", result.error);
}

Pensar en contratos ayuda aquí. El flujo define sus entradas y salidas, la CLI genera tipos a partir de ellas y el front end depende de esos tipos en lugar de depender de los detalles internos del flujo. Esa separación también es más fácil de razonar y verificar para un agente de IA.


Skills listos para usar en Power Platform

No tienes que empezar desde cero. Microsoft mantiene un marketplace open source (MIT) llamado Power Platform Skills con plugins para GitHub Copilot y Claude Code (Microsoft, n.d.-e). Entre ellos:

PluginQué cubre
Code AppsCrear y desplegar code apps conectadas mediante conectores (React + Vite + TypeScript)
Power AutomateCrear, editar, ejecutar y depurar flujos de nube mediante un servidor MCP
Canvas AppsCrear canvas apps mediante un servidor MCP de Canvas Authoring
Model AppsCrear apps basadas en modelo de principio a fin
DataverseConsultar y modificar registros, administrar tablas, seguridad y soluciones

La instalación desde una sesión de Claude Code o de GitHub Copilot CLI sigue este patrón (Microsoft, n.d.-e):

/plugin marketplace add microsoft/power-platform-skills
/plugin install code-apps-preview@power-platform-skills
/plugin install power-automate@power-platform-skills

Algunas notas prácticas del propio repositorio:

  • Los nombres de los plugins, su estado (algunos están marcados como preview) y sus requisitos cambian con el tiempo, así que lee la página de cada plugin antes de instalarlo.
  • Usa un entorno de desarrollador gratuito para aprender, en lugar de un entorno con aplicaciones o datos reales.
  • Lee cada solicitud de permiso antes de aprobarla. Las opciones de aprobación automática dan al agente el mismo acceso que tú tienes en tu equipo y solo se recomiendan en entornos confiables o aislados.
  • Algunos plugins envían telemetría de uso por defecto, y cada uno tiene una forma de desactivarla.

Incluso si usas estos plugins, entender cómo se construye un Skill te ayuda a leerlos, auditarlos y adaptarlos.


Juntando las piezas: un Skill y un revisor para code apps

Este es un ejemplo conceptual de cómo podrían combinarse las piezas en un proyecto de code app. Es un boceto, no una plantilla oficial.

Estructura del proyecto

.claude/
├── skills/
│   ├── code-app-build/
│   │   ├── SKILL.md
│   │   ├── references/
│   │   │   ├── architecture.md
│   │   │   ├── security.md
│   │   │   └── flows.md
│   │   └── scripts/
│   │       └── verify-project.*
│   └── code-app-deploy/
│       └── SKILL.md            ← solo manual, porque publica
└── agents/
    ├── code-app-reviewer.md
    └── code-app-tester.md

Un Skill de construcción

---
name: code-app-build
description: Build or modify a Power Apps code app (React + TypeScript + Vite). Use when creating a code app, adding a connector or a Power Automate flow, or refactoring its architecture.
---

## Workflow

1. Read the requirements and ask about anything ambiguous.
2. Keep UI components separate from data access. Put connector and flow
   calls behind interfaces so they can be replaced in tests.
3. Add data sources and flows with the Power Apps CLI. Never edit
   generated models or services by hand.
4. Use synthetic data for development and tests.
5. Run `npm run build` and the project's verification script before
   reporting that work is complete.

## References

- Architecture rules: see [references/architecture.md](references/architecture.md)
- Security checklist: see [references/security.md](references/security.md)
- Calling Power Automate flows: see [references/flows.md](references/flows.md)

Un Skill de despliegue solo manual

Publicar modifica un entorno, así que no debería ser algo que Claude decida hacer por su cuenta. La documentación recomienda disable-model-invocation: true precisamente para este tipo de flujos (Anthropic, n.d.-b):

---
name: code-app-deploy
description: Publish the code app to the target Power Platform environment
disable-model-invocation: true
---

1. Confirm the target environment ID with the user.
2. Run `npm run build`.
3. Run `pa app push`.
4. Report the resulting URL.

Un subagente revisor de solo lectura

---
name: code-app-reviewer
description: Reviews a Power Apps code app for architecture, security, permissions, and maintainability. Use after significant changes and before any deployment.
tools: Read, Grep, Glob
skills:
  - code-app-build
---

You are a critical reviewer. Do not modify files.

Review the changes for:

- separation between UI, business logic, and integrations;
- handling of sensitive data and secrets;
- permission and role assumptions;
- input validation and error handling;
- anything that conflicts with the preloaded Skill.

Report findings grouped as Critical, Warning, and Suggestion, each with
a file reference and a recommended fix.

Como este subagente no tiene las herramientas Edit, Write ni Bash, no puede cambiar archivos ni ejecutar comandos. Un subagente tester separado necesitaría Bash para ejecutar la app y las pruebas, y esa es una buena razón para mantener ambos roles separados.

Flujo general

Desarrollador (aprobación humana)
        │
        ▼
Agente principal (Claude Code)
        │  usa
        ▼
Skill de construcción (workflow + referencias + scripts)
        │
        ├──► Subagente revisor  → hallazgos
        └──► Subagente tester   → resultados
                    │
                    ▼
        Revisión y decisión humana

El agente principal coordina, el Skill aporta el procedimiento, los subagentes aportan perspectivas especializadas e independientes, los scripts aportan verificaciones deterministas y una persona toma la decisión final.


Guardrails: un prompt no es un control de seguridad

Esta es la lección más importante del artículo.

Decirle a un agente “nunca hagas X” puede orientar su comportamiento, pero no debería ser tu única barrera. La documentación de Claude Code es explícita: las reglas de permisos las aplica Claude Code, no el modelo. Las instrucciones en un prompt o en CLAUDE.md moldean lo que Claude intenta hacer, pero no cambian lo que Claude Code permite (Anthropic, n.d.-c).

Algunos mecanismos útiles:

  • Reglas de permisos. Se evalúan en el orden deny, luego ask y luego allow, y gana la primera coincidencia (Anthropic, n.d.-c).
  • Restricciones de herramientas en subagentes. Una lista tools o una lista de denegación disallowedTools limita lo que cada subagente puede hacer (Anthropic, n.d.-a).
  • Hooks. Un hook PreToolUse puede inspeccionar un comando antes de ejecutarse y bloquearlo saliendo con código 2 (Anthropic, n.d.-a).
  • Sandboxing. Ofrece aplicación a nivel de sistema operativo para los comandos de shell y sigue vigente aunque una inyección de prompt eluda la toma de decisiones del modelo (Anthropic, n.d.-c).
  • Entornos separados y credenciales de mínimo privilegio, que no son específicos de Claude Code pero importan igual. Por eso el repositorio de plugins de Microsoft recomienda entornos de desarrollador para experimentar (Microsoft, n.d.-e).

Un punto de partida para el caso de Power Platform podría ser exigir confirmación antes de publicar cualquier cosa. Esta configuración es únicamente ilustrativa. Las reglas deben adaptarse a los comandos y permisos reales del proyecto; no sustituyen el sandboxing, las restricciones del entorno ni la aprobación humana.

{
  "permissions": {
    "allow": ["Bash(npm run *)"],
    "ask": ["Bash(pa app push *)"],
    "deny": ["Bash(git push *)"]
  }
}

Ten presentes los límites. La documentación explica que una regla de Bash coincide con el texto del comando que escribe Claude y “no es un límite de seguridad alrededor del programa”: el mismo programa invocado de otra forma, por ejemplo mediante sh -c o con ruta completa, puede no coincidir. Para garantías que no dependan del texto del comando, usa sandboxing o un hook (Anthropic, n.d.-c).

Además, revisa los Skills de terceros antes de usarlos. La documentación advierte que un skill de proyecto puede preaprobar herramientas mediante allowed-tools, incluso en una carpeta en la que aún no confías, por lo que debes revisar los allowed-tools de los skills incluidos en un repositorio antes de ejecutar Claude Code ahí (Anthropic, n.d.-b).


IA probabilística y controles deterministas

Un modelo es muy bueno interpretando código, comparando alternativas, detectando patrones sospechosos y explicando hallazgos. Para muchas otras preguntas, una herramienta tradicional da una respuesta objetiva:

¿El proyecto compila?                → ejecutar el build.
¿Pasan las pruebas?                  → ejecutar el test runner.
¿Hay errores de lint?                → ejecutar el linter.
¿Cambió un archivo?                  → preguntarle a Git.
¿Existe una configuración requerida? → validarla con un script.

Tiene poco valor pedirle a un modelo que imagine un resultado que puedes verificar directamente. Una regla útil es: usa IA para razonar y herramientas deterministas para verificar siempre que sea posible. Anthropic plantea algo similar sobre los agentes de programación: el código se puede verificar con pruebas automatizadas, lo que permite al agente iterar con los resultados, pero la revisión humana sigue siendo crucial para asegurar que las soluciones se alineen con los requerimientos más amplios del sistema (Anthropic, 2024).


Evaluar tus Skills y agentes

Un Skill que se activa no es necesariamente un Skill que funciona. La documentación de Claude Code sugiere medir por separado dos cosas: si Claude invoca el Skill con los prompts que debería y si la salida coincide con lo esperado cuando lo hace (Anthropic, n.d.-b).

El método recomendado es una comparación contra una línea base:

  1. Reúne algunos prompts realistas.
  2. Ejecuta cada uno en una sesión nueva con el Skill disponible y de nuevo con el Skill desactivado.
  3. Compara los resultados.

Una sesión nueva es importante porque el contexto restante de haber escrito el Skill puede ocultar vacíos en sus instrucciones. La documentación también describe herramientas que automatizan este ciclo, como claude plugin eval para Skills distribuidos en plugins y el plugin skill-creator para iterar sobre un solo Skill (Anthropic, n.d.-b).

Para la aplicación en sí, apóyate en las herramientas clásicas: pruebas unitarias, pruebas de extremo a extremo, linting, análisis estático y CI/CD. Un agente puede escribir y ejecutar pruebas, pero una prueba que pasa ejecutada por un agente es evidencia, no certificación.


La supervisión humana sigue siendo parte de la arquitectura

El objetivo no es sacar a las personas del proceso, sino colocar la atención humana donde aporta más valor.

Un agente puede explorar veinte archivos, un script puede validar cien configuraciones y un subagente puede hacer una primera revisión. Una persona todavía debe decidir:

  • ¿Entendimos bien el requerimiento?
  • ¿Tiene sentido esta arquitectura?
  • ¿Aceptamos este riesgo y aplica realmente este hallazgo?
  • ¿Son apropiados estos permisos para estos datos?
  • ¿Hay evidencia suficiente para desplegar?
  • ¿Qué pasa si falla?

La IA aumenta la capacidad. No transfiere la responsabilidad.


Cómo empezar

Evita comenzar con cinco agentes, veinte Skills y una arquitectura enorme. Un camino gradual funciona mejor:

  1. Usa un solo agente en una tarea que ya entiendas bien, en un entorno de desarrollador con datos sintéticos.
  2. Observa qué instrucciones repites. Si un procedimiento vuelve una y otra vez, conviértelo en un Skill.
  3. Delega de forma selectiva. Si una tarea secundaria inunda tu contexto o requiere otra responsabilidad, como revisar, considera un subagente con herramientas restringidas.
  4. Convierte las verificaciones en código. Si algo puede validarse con un script o una prueba, hazlo así en lugar de pedirle opinión al modelo.
  5. Bloquea los pasos peligrosos. Usa reglas de permisos, hooks y entornos separados para todo lo que publique, elimine o toque datos reales.
  6. Mide. Compara los resultados con y sin el Skill, e itera.

La arquitectura agéntica debe surgir de una necesidad, no ser un requisito previo para poder decir que se usa Agentic AI.


Qué tener en cuenta

  • Estas herramientas evolucionan rápido. Claude Code se actualiza con frecuencia, y los plugins de Power Platform y las funciones de code apps cambian a menudo. Verifica detalles como requisitos de versión y limitaciones en la documentación vigente.
  • El costo y el contexto son restricciones reales. Los subagentes y los Skills extensos consumen tokens y límites de uso.
  • El licenciamiento y la gobernanza siguen aplicando. Las code apps requieren la configuración correcta del entorno y el licenciamiento de los usuarios finales, y siguen las políticas de plataforma administrada de tu organización.
  • Generado no significa revisado. El código producido por un agente necesita la misma revisión, pruebas y verificaciones de seguridad que cualquier otro código.

Conclusión

Agentic AI no se trata solo de darle más autonomía a un modelo. Se trata de diseñar la relación entre modelo, contexto, conocimiento, herramientas, verificación, permisos y supervisión humana.

Los Skills convierten procedimientos recurrentes en conocimiento reutilizable. Los subagentes separan responsabilidades y mantienen limpio el contexto. Los hooks, los permisos y el sandboxing aportan controles reales que un prompt no puede dar. Y Power Platform ofrece a ese proceso un destino concreto: una code app para el front end y flujos de Power Automate para la lógica de negocio gobernada.

La pregunta que vale la pena hacerse ya no es solo “¿qué código puede generarme la IA?”, sino “¿qué proceso de ingeniería puedo construir para que la IA me ayude a entregar mejor software?”


Referencias

Anthropic. (2024, 19 de diciembre). Building effective agents. https://www.anthropic.com/research/building-effective-agents

Anthropic. (s. f.-a). Create custom subagents. Claude Code Docs. Recuperado el 6 de noviembre de 2026, de https://code.claude.com/docs/en/sub-agents

Anthropic. (s. f.-b). Extend Claude with skills. Claude Code Docs. Recuperado el 6 de noviembre de 2026, de https://code.claude.com/docs/en/skills

Anthropic. (s. f.-c). Configure permissions. Claude Code Docs. Recuperado el 6 de noviembre de 2026, de https://code.claude.com/docs/en/permissions

Microsoft. (s. f.-a). Power Apps code apps overview. Microsoft Learn. Recuperado el 6 de noviembre de 2026, de https://learn.microsoft.com/en-us/power-apps/developer/code-apps/overview

Microsoft. (s. f.-b). Power Apps code apps architecture. Microsoft Learn. Recuperado el 6 de noviembre de 2026, de https://learn.microsoft.com/en-us/power-apps/developer/code-apps/architecture

Microsoft. (s. f.-c). Quickstart: Create a code app using the Power Apps CLI. Microsoft Learn. Recuperado el 6 de noviembre de 2026, de https://learn.microsoft.com/en-us/power-apps/developer/code-apps/how-to/create-an-app-from-scratch

Microsoft. (s. f.-d). Add Power Automate flows to a code app. Microsoft Learn. Recuperado el 6 de noviembre de 2026, de https://learn.microsoft.com/en-us/power-apps/developer/code-apps/how-to/add-flows

Microsoft. (s. f.-e). Power Platform Skills [Repositorio de código fuente]. GitHub. Recuperado el 6 de noviembre de 2026, de https://github.com/microsoft/power-platform-skills