@maestro-ai/mcp-server 1.0.0

package/dist/content/design-system/stacks/vue.csv

@@ -0,0 +1,50 @@
+No,Category,Guideline,Description,Do,Don't,Code Good,Code Bad,Severity,Docs URL
+1,Composition,Use Composition API for new projects,Composition API offers better TypeScript support and logic reuse,<script setup> for components,Options API for new projects,<script setup>,export default { data() },Medium,https://vuejs.org/guide/extras/composition-api-faq.html
+2,Composition,Use script setup syntax,Cleaner syntax with automatic exports,<script setup> with defineProps,setup() function manually,<script setup>,<script> setup() { return {} },Low,https://vuejs.org/api/sfc-script-setup.html
+3,Reactivity,Use ref for primitives,ref() for primitive values that need reactivity,ref() for strings numbers booleans,reactive() for primitives,const count = ref(0),const count = reactive(0),Medium,https://vuejs.org/guide/essentials/reactivity-fundamentals.html
+4,Reactivity,Use reactive for objects,reactive() for complex objects and arrays,reactive() for objects with multiple properties,ref() for complex objects,const state = reactive({ user: null }),const state = ref({ user: null }),Medium,
+5,Reactivity,Access ref values with .value,Remember .value in script unwrap in template,Use .value in script,Forget .value in script,count.value++,count++ (in script),High,
+6,Reactivity,Use computed for derived state,Computed properties cache and update automatically,computed() for derived values,Methods for derived values,const doubled = computed(() => count.value * 2),const doubled = () => count.value * 2,Medium,https://vuejs.org/guide/essentials/computed.html
+7,Reactivity,Use shallowRef for large objects,Avoid deep reactivity for performance,shallowRef for large data structures,ref for large nested objects,const bigData = shallowRef(largeObject),const bigData = ref(largeObject),Medium,https://vuejs.org/api/reactivity-advanced.html#shallowref
+8,Watchers,Use watchEffect for simple cases,Auto-tracks dependencies,watchEffect for simple reactive effects,watch with explicit deps when not needed,watchEffect(() => console.log(count.value)),"watch(count, (val) => console.log(val))",Low,https://vuejs.org/guide/essentials/watchers.html
+9,Watchers,Use watch for specific sources,Explicit control over what to watch,watch with specific refs,watchEffect for complex conditional logic,"watch(userId, fetchUser)",watchEffect with conditionals,Medium,
+10,Watchers,Clean up side effects,Return cleanup function in watchers,Return cleanup in watchEffect,Leave subscriptions open,watchEffect((onCleanup) => { onCleanup(unsub) }),watchEffect without cleanup,High,
+11,Props,Define props with defineProps,Type-safe prop definitions,defineProps with TypeScript,Props without types,defineProps<{ msg: string }>(),defineProps(['msg']),Medium,https://vuejs.org/guide/typescript/composition-api.html#typing-component-props
+12,Props,Use withDefaults for default values,Provide defaults for optional props,withDefaults with defineProps,Defaults in destructuring,"withDefaults(defineProps<Props>(), { count: 0 })",const { count = 0 } = defineProps(),Medium,
+13,Props,Avoid mutating props,Props should be read-only,Emit events to parent for changes,Direct prop mutation,"emit('update:modelValue', newVal)",props.modelValue = newVal,High,
+14,Emits,Define emits with defineEmits,Type-safe event emissions,defineEmits with types,Emit without definition,defineEmits<{ change: [id: number] }>(),"emit('change', id) without define",Medium,https://vuejs.org/guide/typescript/composition-api.html#typing-component-emits
+15,Emits,Use v-model for two-way binding,Simplified parent-child data flow,v-model with modelValue prop,:value + @input manually,"<Child v-model=""value""/>","<Child :value=""value"" @input=""value = $event""/>",Low,https://vuejs.org/guide/components/v-model.html
+16,Lifecycle,Use onMounted for DOM access,DOM is ready in onMounted,onMounted for DOM operations,Access DOM in setup directly,onMounted(() => el.value.focus()),el.value.focus() in setup,High,https://vuejs.org/api/composition-api-lifecycle.html
+17,Lifecycle,Clean up in onUnmounted,Remove listeners and subscriptions,onUnmounted for cleanup,Leave listeners attached,onUnmounted(() => window.removeEventListener()),No cleanup on unmount,High,
+18,Lifecycle,Avoid onBeforeMount for data,Use onMounted or setup for data fetching,Fetch in onMounted or setup,Fetch in onBeforeMount,onMounted(async () => await fetchData()),onBeforeMount(async () => await fetchData()),Low,
+19,Components,Use single-file components,Keep template script style together,.vue files for components,Separate template/script files,Component.vue with all parts,Component.js + Component.html,Low,
+20,Components,Use PascalCase for components,Consistent component naming,PascalCase in imports and templates,kebab-case in script,<MyComponent/>,<my-component/>,Low,https://vuejs.org/style-guide/rules-strongly-recommended.html
+21,Components,Prefer composition over mixins,Composables replace mixins,Composables for shared logic,Mixins for code reuse,const { data } = useApi(),mixins: [apiMixin],Medium,
+22,Composables,Name composables with use prefix,Convention for composable functions,useFetch useAuth useForm,getData or fetchApi,export function useFetch(),export function fetchData(),Medium,https://vuejs.org/guide/reusability/composables.html
+23,Composables,Return refs from composables,Maintain reactivity when destructuring,Return ref values,Return reactive objects that lose reactivity,return { data: ref(null) },return reactive({ data: null }),Medium,
+24,Composables,Accept ref or value params,Use toValue for flexible inputs,toValue() or unref() for params,Only accept ref or only value,const val = toValue(maybeRef),const val = maybeRef.value,Low,https://vuejs.org/api/reactivity-utilities.html#tovalue
+25,Templates,Use v-bind shorthand,Cleaner template syntax,:prop instead of v-bind:prop,Full v-bind syntax,"<div :class=""cls"">","<div v-bind:class=""cls"">",Low,
+26,Templates,Use v-on shorthand,Cleaner event binding,@event instead of v-on:event,Full v-on syntax,"<button @click=""handler"">","<button v-on:click=""handler"">",Low,
+27,Templates,Avoid v-if with v-for,v-if has higher priority causes issues,Wrap in template or computed filter,v-if on same element as v-for,<template v-for><div v-if>,<div v-for v-if>,High,https://vuejs.org/style-guide/rules-essential.html#avoid-v-if-with-v-for
+28,Templates,Use key with v-for,Proper list rendering and updates,Unique key for each item,Index as key for dynamic lists,"v-for=""item in items"" :key=""item.id""","v-for=""(item, i) in items"" :key=""i""",High,
+29,State,Use Pinia for global state,Official state management for Vue 3,Pinia stores for shared state,Vuex for new projects,const store = useCounterStore(),Vuex with mutations,Medium,https://pinia.vuejs.org/
+30,State,Define stores with defineStore,Composition API style stores,Setup stores with defineStore,Options stores for complex state,"defineStore('counter', () => {})","defineStore('counter', { state })",Low,
+31,State,Use storeToRefs for destructuring,Maintain reactivity when destructuring,storeToRefs(store),Direct destructuring,const { count } = storeToRefs(store),const { count } = store,High,https://pinia.vuejs.org/core-concepts/#destructuring-from-a-store
+32,Routing,Use useRouter and useRoute,Composition API router access,useRouter() useRoute() in setup,this.$router this.$route,const router = useRouter(),this.$router.push(),Medium,https://router.vuejs.org/guide/advanced/composition-api.html
+33,Routing,Lazy load route components,Code splitting for routes,() => import() for components,Static imports for all routes,component: () => import('./Page.vue'),component: Page,Medium,https://router.vuejs.org/guide/advanced/lazy-loading.html
+34,Routing,Use navigation guards,Protect routes and handle redirects,beforeEach for auth checks,Check auth in each component,router.beforeEach((to) => {}),Check auth in onMounted,Medium,
+35,Performance,Use v-once for static content,Skip re-renders for static elements,v-once on never-changing content,v-once on dynamic content,<div v-once>{{ staticText }}</div>,<div v-once>{{ dynamicText }}</div>,Low,https://vuejs.org/api/built-in-directives.html#v-once
+36,Performance,Use v-memo for expensive lists,Memoize list items,v-memo with dependency array,Re-render entire list always,"<div v-for v-memo=""[item.id]"">",<div v-for> without memo,Medium,https://vuejs.org/api/built-in-directives.html#v-memo
+37,Performance,Use shallowReactive for flat objects,Avoid deep reactivity overhead,shallowReactive for flat state,reactive for simple objects,shallowReactive({ count: 0 }),reactive({ count: 0 }),Low,
+38,Performance,Use defineAsyncComponent,Lazy load heavy components,defineAsyncComponent for modals dialogs,Import all components eagerly,defineAsyncComponent(() => import()),import HeavyComponent from,Medium,https://vuejs.org/guide/components/async.html
+39,TypeScript,Use generic components,Type-safe reusable components,Generic with defineComponent,Any types in components,"<script setup lang=""ts"" generic=""T"">",<script setup> without types,Medium,https://vuejs.org/guide/typescript/composition-api.html
+40,TypeScript,Type template refs,Proper typing for DOM refs,ref<HTMLInputElement>(null),ref(null) without type,const input = ref<HTMLInputElement>(null),const input = ref(null),Medium,
+41,TypeScript,Use PropType for complex props,Type complex prop types,PropType<User> for object props,Object without type,type: Object as PropType<User>,type: Object,Medium,
+42,Testing,Use Vue Test Utils,Official testing library,mount shallowMount for components,Manual DOM testing,import { mount } from '@vue/test-utils',document.createElement,Medium,https://test-utils.vuejs.org/
+43,Testing,Test component behavior,Focus on inputs and outputs,Test props emit and rendered output,Test internal implementation,expect(wrapper.text()).toContain(),expect(wrapper.vm.internalState),Medium,
+44,Forms,Use v-model modifiers,Built-in input handling,.lazy .number .trim modifiers,Manual input parsing,"<input v-model.number=""age"">","<input v-model=""age""> then parse",Low,https://vuejs.org/guide/essentials/forms.html#modifiers
+45,Forms,Use VeeValidate or FormKit,Form validation libraries,VeeValidate for complex forms,Manual validation logic,useField useForm from vee-validate,Custom validation in each input,Medium,
+46,Accessibility,Use semantic elements,Proper HTML elements in templates,button nav main for purpose,div for everything,<button @click>,<div @click>,High,
+47,Accessibility,Bind aria attributes dynamically,Keep ARIA in sync with state,":aria-expanded=""isOpen""",Static ARIA values,":aria-expanded=""menuOpen""","aria-expanded=""true""",Medium,
+48,SSR,Use Nuxt for SSR,Full-featured SSR framework,Nuxt 3 for SSR apps,Manual SSR setup,npx nuxi init my-app,Custom SSR configuration,Medium,https://nuxt.com/
+49,SSR,Handle hydration mismatches,Client/server content must match,ClientOnly for browser-only content,Different content server/client,<ClientOnly><BrowserWidget/></ClientOnly>,<div>{{ Date.now() }}</div>,High,

package/dist/content/examples/Exemplo de Fluxo Completo com Java e Spring Boot.md

@@ -0,0 +1,250 @@
+# Exemplo de Fluxo Completo com Java e Spring Boot
+
+Este exemplo mostra como aplicar o **Playbook de Desenvolvimento com IA**
+para implementar uma funcionalidade simples em **Java + Spring Boot**.
+
+Funcionalidade de exemplo: **Cadastro de Clientes** em uma API REST.
+
+---
+
+## 1. Visão & Problema
+
+### Contexto
+
+Precisamos de uma API que permita cadastrar clientes (nome, email, CPF) e consultá-los.
+O sistema será usado por um painel administrativo simples.
+
+### Prompt sugerido
+
+```text
+Você é um arquiteto de software sênior especializado em Java e Spring Boot.
+
+Contexto:
+- API REST de cadastro de clientes
+- Campos: nome, email, cpf
+- Banco: PostgreSQL
+
+Me ajude a descrever a visão técnica mínima dessa API, incluindo:
+- objetivo
+- atores
+- fluxos principais (criar, listar, buscar por ID)
+- riscos ou pontos de atenção.
+```
+
+---
+
+## 2. Engenharia de Requisitos com IA
+
+### Requisitos funcionais (esperados)
+
+- RF1: Cadastrar cliente com `nome`, `email`, `cpf`.
+- RF2: Listar todos os clientes.
+- RF3: Buscar cliente por ID.
+
+### Requisitos não funcionais (exemplos)
+
+- RNF1: Validar formato de e-mail.
+- RNF2: Validar CPF (formato e dígitos verificadores).
+- RNF3: API deve ter logs mínimos para auditoria.
+
+### Prompt sugerido
+
+```text
+Com base na visão abaixo:
+[COLE VISÃO]
+
+Detalhe os requisitos funcionais e não funcionais para essa API de clientes.
+Inclua critérios de aceitação para cada requisito.
+```
+
+---
+
+## 3. Modelagem & Arquitetura com IA
+
+### Modelo de domínio esperado
+
+Entidade `Cliente`:
+- id (Long ou UUID)
+- nome (String)
+- email (String)
+- cpf (String)
+- criadoEm (LocalDateTime)
+
+### Prompt para modelo de domínio
+
+```text
+A partir dos requisitos a seguir:
+[COLE REQUISITOS]
+
+Proponha o modelo de domínio para a entidade Cliente em Java:
+- campos e tipos
+- validações necessárias
+
+Sugira também anotações JPA/Bean Validation típicas.
+```
+
+### Prompt para arquitetura/API
+
+```text
+Com a entidade Cliente definida,
+
+Descreva a API REST em Spring Boot:
+- endpoints (método + URI)
+- payloads de requisição
+- formatos de resposta
+- códigos de status para sucesso/erro.
+```
+
+---
+
+## 4. Planejamento / Backlog com IA
+
+### User story
+
+```text
+Como um atendente do sistema administrativo,
+Quero cadastrar e consultar clientes,
+Para que eu possa gerenciar o relacionamento com eles.
+```
+
+### Prompt para backlog
+
+```text
+Usando a user story e os requisitos abaixo:
+[COLE]
+
+Crie uma lista de tarefas técnicas para implementar essa API em Spring Boot:
+- criação da entidade JPA
+- criação do repositório (Spring Data JPA)
+- criação do service
+- criação do controller
+- testes unitários e de integração.
+
+Ordene as tarefas na sequência recomendada.
+```
+
+---
+
+## 5. Implementação (Vibe Coding Estruturado) com IA
+
+### Passo 1 – Entidade + Repositório
+
+```text
+Vamos implementar a entidade Cliente e o repositório em Spring Boot.
+
+Requisitos da entidade:
+- id, nome, email, cpf, criadoEm
+- validação de email
+- validação simples de CPF (não vazio, formato XXX.XXX.XXX-YY ou só dígitos)
+
+Gere o código da classe `Cliente` anotada com JPA e Bean Validation,
+e a interface `ClienteRepository` com Spring Data JPA.
+```
+
+### Passo 2 – Service
+
+```text
+Com base na entidade Cliente e no ClienteRepository:
+[COLE DECLARAÇÕES]
+
+Implemente o `ClienteService` com métodos:
+- criarCliente(dto)
+- listarClientes()
+- buscarPorId(id)
+
+Inclua validações de negócio básicas e tratamento de erros.
+```
+
+### Passo 3 – Controller
+
+```text
+Agora gere o `ClienteController` em Spring Boot expondo:
+- POST /clientes
+- GET /clientes
+- GET /clientes/{id}
+
+Use DTOs para entrada/saída, ResponseEntity para respostas,
+ e retorne códigos apropriados (201, 200, 404, 400).
+```
+
+---
+
+## 6. Testes com IA
+
+### Testes unitários (service)
+
+```text
+Aqui está a implementação de ClienteService:
+[COLE]
+
+Gere testes unitários com JUnit + Mockito cobrindo:
+- criação de cliente válido
+- erro ao tentar criar cliente com email inválido
+- erro ao buscar cliente inexistente.
+```
+
+### Testes de integração (API)
+
+```text
+Com base no ClienteController e na configuração Spring Boot padrão:
+[COLE]
+
+Sugira testes de integração usando @SpringBootTest ou @WebMvcTest,
+validando:
+- POST /clientes com payload válido (201)
+- POST /clientes com email inválido (400)
+- GET /clientes retornando lista
+- GET /clientes/{id} para cliente inexistente (404).
+```
+
+---
+
+## 7. Documentação & Revisão com IA
+
+### Prompt para documentação técnica
+
+```text
+Considere a API de clientes implementada em Spring Boot.
+
+Gere uma documentação técnica em formato Markdown contendo:
+- visão geral da API
+- endpoints
+- exemplos de requisição/resposta
+- principais validações e erros.
+```
+
+### Prompt para revisão de código
+
+```text
+Atue como revisor de código sênior em Java.
+
+Aqui estão as classes Cliente, ClienteService e ClienteController:
+[COLE]
+
+Avalie qualidade de código, manutenibilidade e possíveis bugs.
+Sugira melhorias e refatorações se necessário.
+```
+
+---
+
+## 8. Feedback & Evolução
+
+Depois que a API estiver em produção, IA pode ajudar a:
+
+- analisar logs de erro
+- sugerir melhorias de validação
+- propor campos adicionais úteis (telefone, endereço etc.).
+
+Prompt exemplo:
+
+```text
+Aqui estão registros de erros e feedbacks de usuários sobre o cadastro de clientes:
+[COLE]
+
+Classifique em:
+- bugs
+- problemas de UX da API (mensagens confusas, validações frágeis)
+- melhorias de produto.
+
+Sugira ajustes de curto prazo e evoluções possíveis.
+```

package/dist/content/examples/Exemplo de Fluxo Completo com Laravel e Filament.md

@@ -0,0 +1,278 @@
+# Exemplo de Fluxo Completo com Laravel e Filament (Plano 5)
+
+Este exemplo mostra, de forma resumida, como aplicar o **Playbook de Desenvolvimento com IA**
+para construir um **Site Premium com painel administrativo em Laravel + Filament**.
+
+Funcionalidade de exemplo: **Gestão de Posts de Blog** (CRUD de posts com categorias).
+
+Stack alvo (alinhada ao Plano 5):
+- Laravel 10/11
+- FilamentPHP v3
+- MySQL/MariaDB
+- Hospedagem compartilhada (cPanel/Hostinger/Locaweb etc.).
+
+---
+
+## 1. Visão & Problema
+
+### Contexto
+
+Cliente quer um site institucional com blog gerenciável via painel.
+Precisa:
+- criar/editar posts
+- categorizar conteúdos
+- agendar publicação (opcional)
+- ter URL amigável (slug).
+
+### Prompt sugerido
+
+```text
+Você é um engenheiro de software sênior especialista em Laravel e FilamentPHP.
+
+Contexto:
+- Site institucional com blog
+- Painel administrativo em Filament
+- Banco: MySQL
+- Hospedagem: compartilhada (cPanel/Hostinger etc.)
+
+Me ajude a descrever a visão técnica mínima para um módulo de posts de blog,
+incluindo:
+- objetivo
+- atores (admin, editor)
+- fluxos principais (criar, editar, listar, publicar)
+- riscos ou dúvidas técnicas.
+```
+
+---
+
+## 2. Engenharia de Requisitos com IA
+
+### Requisitos funcionais (esperados)
+
+- RF1: Criar post com título, slug, conteúdo, categoria(s), status (rascunho/publicado).
+- RF2: Editar post existente.
+- RF3: Listar posts com filtros por categoria/status.
+- RF4: Agendar data de publicação (opcional).
+- RF5: Exibir posts publicados no site público.
+
+### Requisitos não funcionais (exemplos)
+
+- RNF1: Painel responsivo e fácil de usar.
+- RNF2: Permissões de acesso (somente usuários autenticados no Filament).
+- RNF3: URLs amigáveis e estáveis.
+
+### Prompt sugerido
+
+```text
+A partir da visão abaixo, detalhe os requisitos funcionais e não funcionais
+para o módulo de posts de blog:
+
+[COLE VISÃO]
+
+Inclua critérios de aceitação em bullets para cada requisito.
+```
+
+---
+
+## 3. Modelagem & Arquitetura com IA
+
+### Modelo de domínio esperado
+
+Entidades principais:
+- `Post`  
+  - id, title, slug, content, status, published_at, created_at, updated_at
+- `Category`  
+  - id, name, slug
+- Relação `Post` N–N `Category`.
+
+### Prompt para modelo de domínio + migrações
+
+```text
+Com base nestes requisitos do módulo de posts:
+[COLE REQUISITOS]
+
+Proponha um modelo de domínio em Laravel,
+com:
+- entidades/tabelas
+- campos e tipos
+- relacionamentos
+
+Gere um esboço das migrações (tabelas posts, categories e tabela pivô),
+sem se preocupar com detalhes de sintaxe.
+```
+
+### Prompt para arquitetura (Laravel + Filament)
+
+```text
+Considerando:
+- Laravel 11
+- Filament v3 para painel administrativo
+
+Descreva a arquitetura do módulo de posts:
+- quais Models serão necessários
+- quais Filament Resources (PostResource, CategoryResource)
+- como será o fluxo entre CRUD do painel e exibição pública dos posts (Blade views).
+```
+
+---
+
+## 4. Planejamento / Backlog com IA
+
+### User story principal
+
+```text
+Como um editor de conteúdo,
+Quero criar, editar e publicar posts de blog pelo painel,
+Para manter o site institucional sempre atualizado.
+```
+
+### Prompt para backlog técnico
+
+```text
+Usando a user story e os requisitos abaixo:
+[COLE]
+
+Gere uma lista de tarefas técnicas para implementar o módulo de posts
+em Laravel + Filament, incluindo:
+- migrações
+- models
+- Filament Resources (forms e tables)
+- rotas e controllers/blade para exibição pública
+- testes básicos (pelo menos de modelo e das rotas públicas).
+
+Organize as tarefas em ordem recomendada.
+```
+
+---
+
+## 5. Implementação (Vibe Coding Estruturado) com IA
+
+### 5.1. Models e migrações
+
+```text
+Vamos implementar os models e migrações para Post e Category em Laravel.
+
+Requisitos de Post:
+- title (string)
+- slug (string único)
+- content (longText)
+- status (enum: draft/published)
+- published_at (nullable datetime)
+
+Requisitos de Category:
+- name (string)
+- slug (string único)
+
+Gere o código das migrações e models com relacionamentos adequados.
+Não gere nada de Filament ainda.
+```
+
+### 5.2. Filament Resources
+
+```text
+Com base nos models Post e Category:
+[COLE DECLARAÇÕES]
+
+Gere o PostResource do Filament com:
+- formulário de criação/edição (title, slug, content, categories, status, published_at)
+- tabela com colunas básicas (title, status, published_at)
+- filtros por categoria e status.
+
+Depois gere o CategoryResource básico.
+```
+
+### 5.3. Rotas e views públicas
+
+```text
+Agora gere as rotas e controllers para exibir posts publicados no site público,
+usando Blade:
+
+- GET /blog -> lista de posts publicados (com paginação)
+- GET /blog/{slug} -> post individual
+
+Inclua consultas usando o model Post e as relações com Category.
+```
+
+---
+
+## 6. Testes com IA
+
+### Testes de modelo
+
+```text
+Aqui estão os models Post e Category:
+[COLE]
+
+Gere testes de modelo em PHPUnit cobrindo:
+- criação de um post com categorias
+- geração e unicidade de slug (se houver lógica específica)
+- escopo para filtrar apenas posts publicados.
+```
+
+### Testes de rotas públicas
+
+```text
+Considere as rotas /blog e /blog/{slug}:
+[COLE CONTROLLERS/ROTAS]
+
+Sugira testes de feature em Laravel testando:
+- listagem de posts publicados
+- não exibição de posts em rascunho
+- acesso a um post específico por slug (200)
+- 404 para slug inexistente.
+```
+
+---
+
+## 7. Documentação & Revisão com IA
+
+### Documentação do módulo
+
+```text
+Com base nos requisitos e no código do módulo de posts (models, resources, controllers):
+[COLE]
+
+Gere uma documentação técnica resumida contendo:
+- visão geral do módulo
+- modelos e relacionamentos
+- rotas principais (painel e público)
+- pontos de extensão (ex.: tags, comentários no futuro).
+```
+
+### Revisão de segurança mínima
+
+```text
+Aqui está a descrição do módulo de posts e os arquivos relevantes:
+[COLE]
+
+Avalie sob a ótica de segurança e boas práticas:
+- permissões de acesso ao painel Filament
+- exposição de dados públicos
+- risco de XSS no conteúdo do post
+
+Sugira medidas de mitigação (ex.: sanitização de HTML, policies, etc.).
+```
+
+---
+
+## 8. Feedback & Evolução
+
+Depois de em produção, IA pode ajudar a:
+
+- analisar quais posts têm mais tráfego (dados de analytics)
+- sugerir melhorias de UX na listagem de posts
+- propor novos campos ou tipos de conteúdo (ex.: destaques, autorias, tags).
+
+Prompt exemplo:
+
+```text
+Aqui estão métricas de acesso ao blog e feedbacks dos usuários:
+[COLE]
+
+Classifique em:
+- melhorias de UX
+- necessidades de novos tipos de conteúdo
+- ajustes técnicos
+
+Sugira uma pequena roadmap de evolução do módulo de blog.
+```