Saltar para o conteúdo principal

Documentation Index

Fetch the complete documentation index at: https://docs.replit.com/llms.txt

Use this file to discover all available pages before exploring further.

​
Primeiros passos

O Replit é um ambiente de desenvolvimento em nuvem capaz de escrever e executar qualquer framework ou stack. Para construir um template personalizado, há dois caminhos recomendados:
  1. Importar de um provedor Git — Importe sua stack inicial existente (ou uma que corresponda às suas preferências) do GitHub, GitLab ou Bitbucket.
  2. Fazer fork do template em branco — Faça fork do template em branco para começar do zero com um ambiente de desenvolvimento completamente vazio.
Clientes construíram com sucesso templates correspondentes a Rust, Python, Java, C++ e muitas outras stacks — se funciona de alguma forma, pode funcionar no Replit.
Recomendamos trabalhar com a equipe de Field Engineering do Replit ao criar seus primeiros templates. Eles têm ampla experiência na configuração de templates personalizados em uma ampla variedade de stacks e estão disponíveis para ajudar. Entre em contato com seu Executivo de Contas para se conectar.
Os templates personalizados permitem que os administradores Enterprise criem pontos de partida pré-configurados que aparecem diretamente na caixa de entrada do Agent para todos os membros da sua organização. Quando um desenvolvedor seleciona um template personalizado, o Agent faz um fork dele e usa a configuração, as instruções e as skills do template para guiar todo o trabalho subsequente. Nenhuma configuração extra necessária.
Os templates personalizados estão disponíveis exclusivamente no plano Enterprise. Apenas administradores da organização podem fixar e gerenciar templates.

​
Como os templates personalizados funcionam

Um template personalizado é um Replit App padrão na sua organização que foi fixado na caixa de entrada do Agent. Quando um desenvolvedor o seleciona:
  1. O Agent cria um novo app fazendo um fork do template (todos os arquivos são copiados)
  2. O Agent pula a fase de planejamento e vai direto para o modo de construção
  3. O arquivo custom_instruction/instructions.md do template é injetado no contexto do Agent
  4. As skills personalizadas de .agents/skills/ são descobertas e disponibilizadas
  5. O arquivo replit.md fornece contexto contínuo do projeto
Isso significa que os padrões, convenções e ferramentas da sua organização são incorporados desde a primeira interação.

​
Estrutura de arquivos do template

Aqui está o layout recomendado para um template personalizado: 
meu-template/
├── .replit                              # Configuração do app (comandos de execução, portas, módulos)
├── replit.md                            # Memória do Agent: visão geral e preferências do projeto
├── custom_instruction/
│   └── instructions.md                  # Instruções da empresa injetadas no prompt do Agent
├── .agents/
│   └── skills/
│       └── minha-skill/
│           └── SKILL.md                 # Skills personalizadas que o Agent pode invocar sob demanda
└── ...                                  # O restante da estrutura do seu repositório
Cada arquivo serve a um propósito distinto. As seções abaixo explicam como configurar cada um.

​
Configurar um template personalizado

​
Criar o app base

Crie um novo Replit App na sua organização. Configure o projeto com todos os arquivos, dependências e configurações que seus desenvolvedores precisam como ponto de partida. Isso inclui:
  • Scaffolding de código-fonte (componentes, utilitários, arquivos de configuração)
  • Dependências pré-instaladas (package.json, requirements.txt, etc.)
  • Configuração de ambiente no arquivo .replit

​
Configurar secrets compartilhados

Se o seu template depende de chaves de API, tokens ou outras credenciais, adicione-os aos Secrets do template (no painel de Ferramentas) antes de fixá-lo. Quando um desenvolvedor cria um novo app a partir do template, todos os secrets são copiados para o novo app automaticamente, para que os desenvolvedores possam começar a trabalhar sem configurar credenciais. Documente cada secret em custom_instruction/instructions.md (ou em uma skill dedicada) para que os desenvolvedores saibam o que está disponível e para que cada chave é usada.
Os secrets são copiados no momento do fork, não sincronizados dinamicamente. Se você rotacionar uma chave ou adicionar um novo secret ao template, os apps existentes que foram previamente forkados não são atualizados. Os desenvolvedores devem adicionar ou atualizar secrets manualmente nesses apps.

​
Escrever instruções personalizadas

Crie um arquivo em custom_instruction/instructions.md na raiz do projeto. Este é o arquivo mais importante do seu template — ele diz ao Agent como sua organização constrói software.
O nome da pasta deve ser custom_instruction (singular), não custom_instructions.
O Agent injeta esse arquivo diretamente em seu prompt do sistema com um preâmbulo que o enquadra como orientação fornecida pela empresa. Escreva em Markdown e inclua:
  • Padrões de arquitetura: Como seus apps devem ser estruturados
  • Padrões de código: Convenções de nomenclatura, regras de organização de arquivos, expectativas de linting
  • Uso de componentes: Quais bibliotecas e componentes usar (e quais evitar)
  • Padrões de API: Como chamar seus serviços de backend, tratar autenticação, gerenciar erros
  • Requisitos de testes: Quais testes são esperados e como executá-los
  • Diretrizes de deployment: Configuração específica do ambiente e fluxos de deploy
# Padrões de Engenharia da Empresa

## Arquitetura
Todos os aplicativos web usam React com TypeScript. Use componentes funcionais
com hooks exclusivamente. O gerenciamento de estado usa Zustand para estado local
e React Query para estado do servidor.

## Biblioteca de Componentes
Use nosso pacote de sistema de design interno `@acme/ui`. Nunca use elementos
HTML brutos para botões, inputs, formulários ou modais — sempre use o
componente correspondente de `@acme/ui`.

Importe componentes assim:
```tsx
import { Button, TextField, Modal } from '@acme/ui';
```

## Integração de API
Todas as chamadas de API passam pelo pacote `@acme/api-client`. Nunca use
fetch bruto ou axios diretamente. A autenticação é tratada automaticamente
pelo cliente.

## Testes
Cada componente deve ter um arquivo de teste correspondente. Use Vitest
para testes unitários e Playwright para testes de integração.
Limite de tamanho: O conteúdo é limitado a aproximadamente 25 KB. O conteúdo além desse limite pode ser progressivamente truncado. À medida que suas instruções crescem, mova o material de referência detalhado para skills em .agents/skills/ em vez de manter tudo em instructions.md. As skills são carregadas sob demanda quando relevantes, portanto não contam para o limite de tamanho das instruções e mantêm suas instruções principais focadas em regras de alto nível.

​
Adicionar skills personalizadas

Crie skills no diretório .agents/skills/ para fluxos de trabalho especializados que o Agent deve seguir. Cada skill é um diretório contendo um arquivo SKILL.md com frontmatter YAML. 
.agents/skills/
├── usar-sistema-de-design/
│   └── SKILL.md
├── integracao-de-api/
│   └── SKILL.md
└── executar-testes/
    └── SKILL.md
Cada SKILL.md precisa de um name e description em seu frontmatter: 
---
name: use-design-system
description: Use when building UI components. Provides component patterns, theming rules, and accessibility requirements for the Acme design system.
---

# Sistema de Design Acme

## Componentes disponíveis

- `Button` — Variantes primária, secundária e ghost
- `TextField` — Input de texto com suporte à validação
- `Modal` — Overlay de diálogo com captura de foco
...
CampoObrigatórioDetalhes
nameSimMáximo de 64 caracteres. Apenas letras minúsculas, números e hífens.
descriptionSimMáximo de 1.024 caracteres. Descreve o que a skill faz e quando usá-la.
enabledNãoPadrão true. Defina como false para desabilitar sem excluir.
Como as skills são carregadas: O Agent vê apenas o name e a description em seu prompt. Ele lê o conteúdo completo do SKILL.md sob demanda quando a skill é relevante para a tarefa atual. Isso significa que a description é crítica — escreva-a para corresponder aos cenários onde o Agent deve usar a skill. As skills também podem incluir arquivos de suporte junto com SKILL.md: 
.agents/skills/usar-sistema-de-design/
├── SKILL.md
├── references/
│   └── component-api.md
└── assets/
    └── theme-tokens.json
Para mais sobre skills, consulte Agent Skills e o tutorial de Agent Skills.

​
Configurar replit.md

Pré-preencha o replit.md na raiz do projeto com a visão geral da arquitetura do seu template. Esse arquivo é sempre carregado no contexto do Agent e serve como memória contínua do projeto. O arquivo deve ter estas quatro seções: 
# Visão Geral
Aplicativo de gerenciamento de tarefas construído com React, TypeScript e o sistema
de design Acme. Usa backend Express.js com PostgreSQL.

# Preferências do Usuário
- Usar TypeScript para todos os arquivos
- Preferir componentes funcionais com hooks
- Seguir os padrões de código Acme

# Arquitetura do Sistema
- Frontend: React + TypeScript + @acme/ui
- Backend: Express.js + TypeScript
- Banco de dados: PostgreSQL com Drizzle ORM
- Auth: Acme SSO via @acme/auth

# Dependências Externas
- @acme/ui: Sistema de design interno
- @acme/api-client: Camada de integração de API
- @acme/auth: SDK de autenticação
O Agent atualiza o replit.md à medida que o projeto evolui. Se o arquivo crescer além de aproximadamente 4.000 tokens, o Agent o resume automaticamente para mantê-lo focado e útil. Para mais detalhes, consulte replit.md.

​
Fixe o template na sua organização

Depois que o seu template estiver pronto:
  1. Navegue até o app do template na sua organização
  2. Abra o menu de ações do app (menu de três pontos)
  3. Selecione Fixar na caixa de entrada do Agent
Menu de ações do app mostrando a opção Fixar na caixa de entrada do Agent
Apenas administradores da organização (membros da função system_admins) podem fixar e desafixar templates.
Defina o acesso dos membros como Somente leitura para que os membros possam ver e usar o template fixado sem poder editá-lo. Diálogo de convite mostrando o acesso dos membros definido como Somente leitura O template agora aparece como uma pílula selecionável abaixo da caixa de entrada do Agent para todos os membros da sua organização. Para removê-lo, abra o mesmo menu e selecione Desafixar da caixa de entrada do Agent.

​
Controlar o acesso ao template

Fixar torna um template visível para todos os membros da organização. Para uma distribuição mais direcionada, use o botão Convidar no app do template para compartilhá-lo com Grupos ou usuários individuais específicos. Isso permite limitar quais equipes ou pessoas podem ver e fazer fork do template, mantendo-o desafixado da caixa de entrada global da organização.

​
O que acontece quando um desenvolvedor seleciona um template

Template aparecendo como uma pílula selecionável na caixa de entrada do Agent Quando um membro da organização escolhe um template fixado na caixa de entrada do Agent:
  1. Fork: Um novo app é criado como uma cópia do template, com todos os arquivos incluídos
  2. Pular planejamento: O Agent ignora a conversa de planejamento inicial e vai diretamente para o modo de construção
  3. Carregar instruções: custom_instruction/instructions.md é lido e injetado no prompt do sistema do Agent como orientação fornecida pela empresa
  4. Descobrir skills: As skills em .agents/skills/ são identificadas e listadas no contexto do Agent para carregamento sob demanda
  5. Carregar contexto do projeto: replit.md é lido e injetado no contexto do Agent (ou gerado automaticamente se estiver faltando)
  6. Herdar configuração: O arquivo .replit, as dependências e todos os arquivos do template são transferidos para o novo app
O desenvolvedor pode imediatamente começar a fazer prompts ao Agent com seus requisitos específicos, e o Agent opera dentro das diretrizes estabelecidas pelo template.

​
Como os arquivos funcionam juntos

Cada arquivo de configuração serve a uma função distinta:
ArquivoPropósitoQuando o Agent o lêMutável pelo Agent
custom_instruction/instructions.mdPadrões e regras da organizaçãoSempre (injetado no prompt do sistema)Não
.agents/skills/*/SKILL.mdFluxos de trabalho e padrões especializadosSob demanda (quando relevante)Sim (o Agent também pode criar skills)
replit.mdVisão geral e preferências do projetoSempre (injetado no prompt do sistema)Sim (o Agent o atualiza ao longo do tempo)
.replitConfiguração de runtimeAo configurar o appSim
Distinção fundamental: custom_instruction/instructions.md é sua fonte estática e autoritativa para os padrões organizacionais. replit.md é o documento vivo que o Agent mantém conforme o projeto evolui. As skills são material de referência sob demanda para fluxos de trabalho específicos.

​
Melhores práticas

​
Mantenha as instruções focadas

Escreva custom_instruction/instructions.md para os padrões que mais importam. Foque em:
  • Decisões difíceis de reverter (arquitetura, modelos de dados)
  • Padrões que devem ser consistentes (uso de componentes, convenções de API)
  • Padrões que o desenvolvedor pode não conhecer (bibliotecas internas, convenções da equipe)
Evite incluir changelogs, detalhes de implementação ou informações que mudam com frequência.

​
Escreva descrições de skills descobríveis

O campo description no frontmatter do SKILL.md é o que o Agent usa para decidir quando carregar uma skill. Escreva descrições que correspondam às tarefas onde a skill é relevante: 
# Bom — descreve quando usar
description: Use when building forms or handling user input. Provides validation patterns, error display conventions, and accessible form layouts.

# Menos eficaz — muito vago
description: Form utilities and helpers.

​
Organize skills por fluxo de trabalho

Agrupe skills em torno de fluxos de trabalho em vez de categorias técnicas:
AbordagemExemplo
Por fluxo de trabalhobuild-a-form, connect-to-api, add-auth
Por área técnicareact-utils, api-helpers, auth-config
A abordagem por fluxo de trabalho ajuda o Agent a descobrir skills no momento certo.

​
Itere no seu template

Os templates melhoram com o uso. Depois que sua equipe começar a construir com um template:
  1. Observe os padrões que o Agent erra e adicione-os a instructions.md
  2. Crie novas skills quando o Agent resolver um problema bem — capture a solução
  3. Atualize as dependências e configurações base conforme sua stack evolui
  4. Teste as alterações criando um novo app a partir do template para verificar a experiência

​
Atualizações de templates e apps existentes

As alterações no app do template são refletidas nos novos apps criados a partir dele. Os apps existentes que foram previamente forkados do template são cópias independentes e não recebem atualizações.

​
Recursos relacionados