# Modo AI
Source: https://docs.synkrony.ai/ai-mode
Automatize tarefas de desenvolvimento com inteligência artificial
# Modo AI
O **Modo AI** é uma funcionalidade revolucionária do Synkrony que utiliza inteligência artificial para automatizar tarefas de desenvolvimento. Com ele, você descreve o que precisa fazer e a IA planeja, implementa e cria Pull Requests automaticamente.
> O Modo AI é powered by **Kanbino**, nosso agente de IA baseado em Claude da Anthropic.
***
## Como Funciona
O Modo AI transforma tarefas descritas em texto em código pronto para revisão através de um fluxo simples e eficiente:
```
Descrição da Tarefa → Planejamento IA → Revisão do Plano → Execução → Pull Request
```
### O Fluxo Completo
Crie uma tarefa no Synkrony com uma descrição clara do que você precisa. Quanto mais detalhes e contexto você fornecer, melhor será o resultado.
**Boas práticas:**
* Descreva o comportamento esperado
* Inclua requisitos específicos
* Mencione arquivos ou módulos relacionados
* Adicione exemplos quando aplicável
Clique no botão **"Executar com AI"** na tarefa. O Synkrony irá acionar o Kanbino para processar sua solicitação.
A IA começará a analisar seu projeto e entender o contexto.
O Kanbino analisa sua codebase e gera um **plano de implementação** detalhado. Revise as etapas propostas antes da execução.
Você pode:
* **Confirmar** o plano → A IA executa automaticamente
* **Pedir alterações** → A IA revisa o plano com seu feedback
* **Fazer perguntas** → A IA esclarece pontos do plano
Após aprovar o plano, a IA implementa o código automaticamente. Acompanhe o progresso em tempo real diretamente no Synkrony.
Durante a execução, a IA:
* Lê os arquivos necessários
* Implementa as mudanças
* Executa testes quando disponível
* Aplica linters e formatters
Ao finalizar, um **Pull Request** é criado automaticamente com todas as mudanças. Revise o código como faria com qualquer PR.
O PR inclui:
* Descrição das mudanças realizadas
* Arquivos modificados/criados
* Commits organizados por etapa
Após o merge do PR, você pode avaliar a qualidade do trabalho da IA.
Seu feedback nos ajuda a melhorar continuamente o sistema.
***
## Interação em Tempo Real
Durante todo o processo, você interage com a IA através de um chat em tempo real:
### Durante o Planejamento
* **Perguntas da IA:** A IA pode fazer perguntas para entender melhor o requisito
* **Esclarecimentos:** Responda dúvidas da IA para refinar o plano
* **Sugestões:** A IA pode sugerir abordagens alternativas
### Durante a Execução
* **Progresso ao vivo:** Veja cada etapa sendo executada
* **Mensagens da IA:** A IA explica o que está fazendo
* **Logs detalhados:** Acompanhe comandos executados e arquivos modificados
### Após a Execução
* **Pull Request:** PR criado automaticamente no seu repositório
* **Feedback:** Avalie a qualidade do trabalho (1-5 estrelas)
* **Comentários:** Deixe feedback textual para melhorias futuras
***
## Quando Usar o Modo AI
O Modo AI é ideal para diversos cenários do dia a dia de desenvolvimento:
### Casos de Uso Recomendados
Implementações com requisitos claros e escopo bem delimitado. Ex: adicionar um campo em um formulário, criar um endpoint simples.
Corrigir issues específicas com descrição detalhada do comportamento indesejado e do esperado.
Melhorar estrutura de código existente mantendo comportamento, como extrair métodos ou reorganizar componentes.
Criar testes unitários, de integração ou end-to-end para funcionalidades existentes.
Adicionar ou atualizar docstrings, comentários e documentação de código.
Atualizar dependências, modificar configurações ou fazer mudanças incrementais.
### Quando Evitar
O Modo AI pode não ser a melhor escolha para:
* **Arquiteturas complexas:** Mudanças que exigem decisões arquiteturais significativas
* **Tarefas vagas:** Descrições sem contexto suficiente ou requisitos mal definidos
* **Mudanças muito grandes:** Alterações que afetam múltiplos módulos simultaneamente
***
## Benefícios do Modo AI
### Para Desenvolvedores
* **Produtividade:** Automatize tarefas repetitivas e foque no que realmente importa
* **Padrão de código:** A IA segue as convenções do seu projeto automaticamente
* **Aprendizado:** Veja como a IA aborda problemas e aprenda novas técnicas
* **Velocidade:** De tarefas que levariam horas para minutos
### Para Times
* **Consistência:** Código gerado segue os mesmos padrões da equipe
* **Code Review:** PRs criados pela IA passam pelo mesmo processo de revisão
* **Escalabilidade:** Execute múltiplas tarefas em paralelo
* **Transparência:** Acompanhe cada etapa da execução em tempo real
### Para Empresas
* **Redução de custos:** Otimize o tempo da equipe em tarefas operacionais
* **Time-to-market:** Entrega mais rápida de features
* **Qualidade:** A IA executa testes e linters antes de criar o PR
* **Conhecimento acumulado:** A IA aprende com o contexto do seu projeto
***
## Fluxo de Revisão do Plano
A revisão do plano é uma etapa crítica onde você garante que a IA entendeu corretamente o requisito.
### O Que Avaliar
1. **Compreensão do requisito:** A IA entendeu o que você precisa?
2. **Abordagem técnica:** A estratégia proposta faz sentido?
3. **Arquivos afetados:** Os arquivos listados são os corretos?
4. **Etapas:** O plano está completo e na ordem certa?
### Como Dar Feedback
* **Se o plano está correto:** Clique em "Confirmar" para aprovar
* **Se precisa de ajustes:** Clique em "Pedir alterações" e descreva o que mudar
* **Se tem dúvidas:** Faça perguntas no chat para esclarecer pontos
### Ciclo de Revisão
```
Plano Gerado → Você Avalia → Confirmar? → Execução
↓
Não → Pedir Alterações → Plano Revisado → Você Avalia Novamente
```
A IA pode refazer o plano quantas vezes for necessário até que você esteja satisfeito.
***
## Coleta de Feedback
Após a conclusão da tarefa, coletamos seu feedback para melhorar o sistema:
> Seu feedback é essencial para treinar e melhorar o Kanbino!
***
## Limites de Execução
A quantidade de execuções do Modo AI depende do seu plano:
| Plano | Execuções/Mês |
| ------------ | -------------- |
| Free Forever | 2 totais |
| Standard | 3 totais |
| AI Mode | 30 por usuário |
| Enterprise | Ilimitadas |
As execuções são contadas por **tarefa completa** - desde o planejamento até a criação do Pull Request.
***
## Dicas para Melhores Resultados
### 1. Descrições Claras
**Ruim:**
> "Adicionar botão"
**Bom:**
> "Adicionar um botão de 'Cancelar' no formulário de criação de tarefa que redireciona o usuário para a página do projeto e exibe uma mensagem de confirmação usando o toast padrão do sistema."
### 2. Forneça Contexto
Inclua informações sobre:
* Stack tecnológico utilizado
* Padrões de arquitetura do projeto
* Convenções de nomenclatura
* Dependências e libs que devem ser usadas
### 3. Defina Requisitos
Especifique claramente:
* Comportamentos esperados
* Casos de borda
* Validações necessárias
* Testes que devem ser criados
### 4. Use Tarefas Focadas
Divida tarefas grandes em subtarefas menores e mais específicas. Tarefas focadas geram melhores resultados.
### 5. Revise o Plano com Cuidado
A etapa de revisão do plano é sua oportunidade de corrigir o curso antes que a IA comece a implementar. Dedique tempo a essa etapa.
***
## Segurança e Privacidade
O Modo AI foi projetado com segurança em mente:
* **Isolamento:** Cada execução roda em ambiente isolado
* **Permissões:** A IA só acessa repositórios autorizados
* **Transparência:** Todas as mudanças ficam no git para revisão
* **Controle:** Você aprova o plano antes da execução
* **Code Review:** PRs passam pelo mesmo processo de revisão humana
***
## ❓ FAQ
**O Modo AI substitui desenvolvedores?**
Não. O Modo AI é uma ferramenta de produtividade que automatiza tarefas repetitivas e bem definidas, permitindo que desenvolvedores foquem em problemas mais complexos.
**Posso confiar no código gerado pela IA?**
Sempre revise o código como faria com qualquer PR. A IA segue padrões do projeto, mas erros podem ocorrer. O code review humano continua essencial.
**O que acontece se a IA cometer um erro?**
Você pode solicitar correções através do chat ou fazer as alterações manualmente no PR. O feedback ajuda a IA a aprender.
**Posso usar o Modo AI em qualquer projeto?**
Sim, desde que o projeto esteja conectado ao GitHub e tenha a integração configurada.
**A IA aprende com meu projeto?**
Sim, a IA analisa seu código para entender padrões, convenções e contexto do projeto.
**Quanto tempo leva uma execução?**
Depende da complexidade da tarefa. Tarefas simples podem levar 5-10 minutos, enquanto tarefas complexas podem levar 30-40 minutos.
***
## Documentação Técnica
Quer saber mais sobre a configuração técnica e arquitetura do Modo AI? Confira a documentação do [Kanbino](/kanbino).
# Atualizar epic
Source: https://docs.synkrony.ai/api-reference/epics/atualizar-epic
/api-reference/v1/swagger.json patch /api/v1/epics/{id}
# Criar epic
Source: https://docs.synkrony.ai/api-reference/epics/criar-epic
/api-reference/v1/swagger.json post /api/v1/epics
# Excluir epic
Source: https://docs.synkrony.ai/api-reference/epics/excluir-epic
/api-reference/v1/swagger.json delete /api/v1/epics/{id}
# Exibir epic
Source: https://docs.synkrony.ai/api-reference/epics/exibir-epic
/api-reference/v1/swagger.json get /api/v1/epics/{id}
# Listar epics
Source: https://docs.synkrony.ai/api-reference/epics/listar-epics
/api-reference/v1/swagger.json get /api/v1/epics
# Arquivar projeto
Source: https://docs.synkrony.ai/api-reference/projects/arquivar-projeto
/api-reference/v1/swagger.json delete /api/v1/projects/{id}
# Atualizar projeto
Source: https://docs.synkrony.ai/api-reference/projects/atualizar-projeto
/api-reference/v1/swagger.json patch /api/v1/projects/{id}
# Criar projeto
Source: https://docs.synkrony.ai/api-reference/projects/criar-projeto
/api-reference/v1/swagger.json post /api/v1/projects
# Exibir projeto
Source: https://docs.synkrony.ai/api-reference/projects/exibir-projeto
/api-reference/v1/swagger.json get /api/v1/projects/{id}
# Listar projetos
Source: https://docs.synkrony.ai/api-reference/projects/listar-projetos
/api-reference/v1/swagger.json get /api/v1/projects
# Exibir sprint
Source: https://docs.synkrony.ai/api-reference/sprints/exibir-sprint
/api-reference/v1/swagger.json get /api/v1/sprints/{id}
# Listar sprints
Source: https://docs.synkrony.ai/api-reference/sprints/listar-sprints
/api-reference/v1/swagger.json get /api/v1/sprints
# Listar colunas de status do Kanban
Source: https://docs.synkrony.ai/api-reference/statuses/listar-colunas-de-status-do-kanban
/api-reference/v1/swagger.json get /api/v1/statuses
# Atualizar tag
Source: https://docs.synkrony.ai/api-reference/tags/atualizar-tag
/api-reference/v1/swagger.json patch /api/v1/tags/{id}
# Criar tag
Source: https://docs.synkrony.ai/api-reference/tags/criar-tag
/api-reference/v1/swagger.json post /api/v1/tags
# Exibir tag
Source: https://docs.synkrony.ai/api-reference/tags/exibir-tag
/api-reference/v1/swagger.json get /api/v1/tags/{id}
# Listar tags
Source: https://docs.synkrony.ai/api-reference/tags/listar-tags
/api-reference/v1/swagger.json get /api/v1/tags
# Remover tag
Source: https://docs.synkrony.ai/api-reference/tags/remover-tag
/api-reference/v1/swagger.json delete /api/v1/tags/{id}
# Atualizar tarefa
Source: https://docs.synkrony.ai/api-reference/tasks/atualizar-tarefa
/api-reference/v1/swagger.json patch /api/v1/tasks/{id}
# Criar tarefa
Source: https://docs.synkrony.ai/api-reference/tasks/criar-tarefa
/api-reference/v1/swagger.json post /api/v1/tasks
# Excluir tarefa
Source: https://docs.synkrony.ai/api-reference/tasks/excluir-tarefa
/api-reference/v1/swagger.json delete /api/v1/tasks/{id}
# Exibir tarefa
Source: https://docs.synkrony.ai/api-reference/tasks/exibir-tarefa
/api-reference/v1/swagger.json get /api/v1/tasks/{id}
# Listar tarefas
Source: https://docs.synkrony.ai/api-reference/tasks/listar-tarefas
/api-reference/v1/swagger.json get /api/v1/tasks
# Atualizar registro de tempo
Source: https://docs.synkrony.ai/api-reference/timelogs/atualizar-registro-de-tempo
/api-reference/v1/swagger.json patch /api/v1/time_logs/{id}
# Criar registro de tempo
Source: https://docs.synkrony.ai/api-reference/timelogs/criar-registro-de-tempo
/api-reference/v1/swagger.json post /api/v1/time_logs
# Exibir registro de tempo
Source: https://docs.synkrony.ai/api-reference/timelogs/exibir-registro-de-tempo
/api-reference/v1/swagger.json get /api/v1/time_logs/{id}
# Listar registros de tempo
Source: https://docs.synkrony.ai/api-reference/timelogs/listar-registros-de-tempo
/api-reference/v1/swagger.json get /api/v1/time_logs
# Remover registro de tempo
Source: https://docs.synkrony.ai/api-reference/timelogs/remover-registro-de-tempo
/api-reference/v1/swagger.json delete /api/v1/time_logs/{id}
# Atualizar usuário
Source: https://docs.synkrony.ai/api-reference/users/atualizar-usuário
/api-reference/v1/swagger.json patch /api/v1/users/{id}
# Criar usuário (convite)
Source: https://docs.synkrony.ai/api-reference/users/criar-usuário-convite
/api-reference/v1/swagger.json post /api/v1/users
# Exibir usuário
Source: https://docs.synkrony.ai/api-reference/users/exibir-usuário
/api-reference/v1/swagger.json get /api/v1/users/{id}
# Listar usuários
Source: https://docs.synkrony.ai/api-reference/users/listar-usuários
/api-reference/v1/swagger.json get /api/v1/users
# Remover usuário
Source: https://docs.synkrony.ai/api-reference/users/remover-usuário
/api-reference/v1/swagger.json delete /api/v1/users/{id}
# Configuração de Tokens de API
Source: https://docs.synkrony.ai/configuracao-api-token
Este guia explica como configurar e gerenciar tokens de API através da interface do Synkrony.
## Acessando o Gerenciamento de API
1. **Faça login** na sua conta do Synkrony
2. **Navegue para Configurações** clicando no menu lateral
3. **Selecione a seção "API"** nas configurações
> Somente o administrador da empresa pode gerenciar tokens de API
## Criando um Novo Token de API
### Passo a Passo
1. **Na página de API**, clique no botão **"Adicionar Chave"**
2. **Digite um nome** descritivo para o seu token (ex: "Integração CRM", "Automação Deploy")
3. **Clique em "Criar"** para gerar o token
### ⚠️ Importante - Copie o Token Imediatamente
* Após a criação, o token completo será exibido **apenas uma vez**
* **Copie e salve o token** em um local seguro
* O sistema mostrará apenas os últimos 4 caracteres do token após essa tela
## Gerenciando Tokens Existentes
### Visualizando Tokens
Na página de API, você verá uma lista com todos os seus tokens contendo:
* **Nome do Token**: Nome descritivo que você definiu
* **Token**: Últimos 4 caracteres (ex: `•••••••••••abcd`)
* **Criado em**: Data de criação do token
* **Último uso**: Data da última utilização (se aplicável)
## Utilizando o Token de API
### Formato de Autenticação
Para usar o token em suas requisições à API, inclua o cabeçalho de autorização:
```
Authorization: Bearer SEU_TOKEN_AQUI
```
### Exemplo de Requisição
```bash theme={null}
curl -H "Authorization: Bearer seu_token_completo_aqui" \
-H "Content-Type: application/json" \
https://synkrony.ai/api/v1/projects
```
### Endpoints Disponíveis
A API do Synkrony oferece os seguintes endpoints:
* `/api/v1/projects` - Gerenciamento de projetos
* `/api/v1/tasks` - Gerenciamento de tarefas
* `/api/v1/project_modules` - Gerenciamento de módulos de projeto
## Segurança e Boas Práticas
### Segurança do Token
* **Mantenha seus tokens seguros**: Nunca compartilhe ou exponha tokens em código público
* **Use nomes descritivos**: Facilita a identificação e gerenciamento
* **Revogue tokens não utilizados**: Remove tokens antigos ou desnecessários
* **Monitore o uso**: Verifique regularmente a data de "último uso"
### Isolamento por Empresa
* Cada token é **restrito à sua empresa**
* Você só pode acessar dados da sua organização
* Tokens não podem ser compartilhados entre empresas diferentes
### Permissões
* Para gerenciar tokens de API, você precisa ter **permissões de administração** na empresa
* Apenas usuários com papel de `owner` ou `super_admin` podem criar, editar ou excluir tokens
## Contato
Para suporte adicional ou documentação avançada da API, entre em contato com nossa equipe de desenvolvimento.
# Documentos
Source: https://docs.synkrony.ai/documentos
Gerencie especificações, arquivos e documentação de projetos
O **Gerenciador de Documentos** do Synkrony permite centralizar toda a documentação dos seus projetos em um único lugar, com suporte a documentos de texto rico e upload de arquivos.
Acesse os documentos através do menu do projeto: **Documentos**.
***
## 📋 Tipos de Documentos
### Documentos de Texto
Crie e edite documentos diretamente na plataforma com editor rico (TipTap):
* **Formatação completa:** negrito, itálico, listas, cabeçalhos
* **Auto-save:** salvo automaticamente enquanto você digita
* **Múltiplas imagens:** adicione capturas de tela e diagramas
* **Não consome armazenamento:** ilimitados para documentos de texto
### Documentos de Arquivo
Faça upload de arquivos de seu computador:
* **Qualquer formato:** PDF, DOCX, XLSX, imagens, etc.
* **Limite de 50MB:** por arquivo
* **Consome armazenamento:** conta na quota da empresa
* **Download direto:** baixe o arquivo original quando precisar
***
## 📁 Organização em Pastas
* **Pastas hierárquicas:** crie estrutura de níveis para organizar
* **Drag & drop:** arraste documentos para mover entre pastas
* **Nome único:** cada pasta em um projeto deve ter nome único
* **Exclusão em cascata:** ao excluir uma pasta, todos os documentos dentro são excluídos
***
## ➕ Criar Documentos
### Documento de Texto
1. Acesse **Documentos** no projeto
2. Clique em **Criar documento vazio**
3. Digite o título e comece a editar
4. O conteúdo é salvo automaticamente
### Upload de Arquivo
1. Acesse **Documentos** no projeto
2. Clique em **Fazer upload** ou arraste o arquivo
3. Aguarde o upload completar
### Dentro de uma Pasta
Abra a pasta desejada e clique em **Criar documento** ou **Upload**.
***
## 🔍 Busca e Filtros
* **Busca por texto:** pesquisa em títulos e conteúdo
* **Filtro por tipo:** documentos de texto, arquivos ou todos
* **Modo busca:** mostra apenas documentos, ocultando pastas
***
## 💾 Limites de Armazenamento
O armazenamento é controlado por empresa:
| Plano | Limite |
| ------------------ | ---------------- |
| Free Forever | 5GB total |
| Standard e AI Mode | 10GB por usuário |
Acompanhe seu uso em **Configurações da empresa**.
***
## ⚙️ Ações Disponíveis
* **Renomear:** menu de ações → Renomear
* **Mover:** arraste para outra pasta ou edite o documento
* **Excluir:** menu de ações → Excluir (confirme a ação)
> ⚠️ Ao excluir uma pasta, todos os documentos dentro são excluídos permanentemente.
***
## ❓ FAQ
**Documentos de texto contam no limite de armazenamento?**
Não. Apenas documentos de arquivo (upload) contam. Documentos criados com o editor são ilimitados.
**Posso mover documentos entre pastas?**
Sim. Use drag & drop ou edite o documento e selecione a nova pasta.
**Posso editar documentos de arquivo (PDF, DOCX)?**
Não. Documentos de arquivo devem ser baixados, editados externamente e reenviados.
**Existe histórico de versões?**
O sistema mantém registro de quando cada documento foi criado e modificado, mas não há versionamento completo de conteúdo.
***
## 📚 Documentação Relacionada
* [Introdução](/introducao) - Conecte documentos às tarefas do projeto
* [Sprints](/sprints) - Organize ciclos de trabalho com documentação adequada
* [Planos](/planos) - Entenda os limites de armazenamento por plano
# Relatório Financeiro
Source: https://docs.synkrony.ai/financial-report
Acompanhe a rentabilidade dos projetos e a saúde financeira da sua Software House
O **Relatório Financeiro** é uma ferramenta completa para Software Houses e agências que desejam acompanhar a rentabilidade dos seus projetos. Através de métricas de receita, custos e margem de contribuição, você obtém insights valiosos para tomar decisões estratégicas sobre preços, recursos e alocação da equipe.
Acesse o relatório através do menu lateral: **Relatórios → Relatório Financeiro**.
***
## 📊 Como Funciona
O relatório financeiro calcula automaticamente a rentabilidade dos seus projetos com base em:
* **Receita:** Valor total dos contratos (fixos ou por hora)
* **Custos da Equipe:** Calculado com base nas horas trabalhadas × custo/hora de cada membro
* **Custos Extras:** Custos adicionais específicos de cada projeto
* **Margem de Contribuição:** Receita menos todos os custos
* **Margem Percentual:** (Margem / Receita) × 100
### Tipos de Contrato
* **Escopo Fixo:** Contratos com valor predeterminado, independente das horas trabalhadas
* **Escopo Flexível:** Contratos por hora, calculados como `custo/hora × horas/sprint × número de sprints`
***
## ⚙️ Configuração
### Custos por Usuário
Para que os custos da equipe sejam calculados corretamente, configure o **custo/hora** de cada membro da equipe:
1. Acesse **Configurações → Equipe**
2. Selecione o membro da equipe
3. Defina o **Custo por Hora** em centavos
> Esta informação é usada exclusivamente para cálculos financeiros internos e não é visível para o usuário.
### Contratos do Projeto
Configure os contratos para calcular a receita corretamente:
1. Acesse a página do projeto
2. Vá em **Financeiro → Contratos**
3. Adicione um contrato com:
* **Escopo:** Fixo ou Flexível
* **Valor:** Custo total (escopo fixo) ou custo/hora (escopo flexível)
* **Status:** Ativo ou Inativo
### Custos Extras
Adicione custos adicionais específicos de cada projeto:
1. Acesse a página do projeto
2. Vá em **Financeiro → Custos Extras**
3. Adicione custos como:
* Licenças de software
* Infraestrutura dedicada
* Serviços terceirizados
* Despesas operacionais
***
## 🔄 Filtros e Visualização
### Filtros por Período
Selecione o período que deseja analisar:
* **Este Mês:** Mostra apenas o mês atual
* **Este Trimestre:** Mostra os 3 meses atuais
* **Este Semestre:** Mostra os 6 meses atuais
* **Este Ano:** Mostra o ano atual
* **Período Personalizado:** Selecione datas específicas
### Modos de Visualização
* **Semanal:** Agrupa os dados por semana
* **Trimestral:** Agrupa os dados por trimestre
* **Semestral:** Agrupa os dados por semestre
* **Anual:** Agrupa os dados por ano
### Filtros por Projeto e Cliente
* **Projetos:** Selecione projetos específicos para analisar
* **Clientes:** Filtre por grupo de clientes
* **Projetos Arquivados:** Toggle para mostrar ou ocultar projetos arquivados
> Os filtros podem ser combinados para obter visões específicas (ex: "Rentabilidade do Cliente X no último trimestre")
***
## 💰 Diferenças Entre Planos
O acesso às funcionalidades financeiras varia conforme o plano da sua empresa:
### Plano Free
No plano gratuito, você tem acesso às **métricas individuais de cada projeto** diretamente na página do projeto:
* **Receita:** Valor total dos contratos do projeto
* **Custos da Equipe:** Calculado com base nas horas trabalhadas × custo/hora
* **Custos Extras:** Soma dos custos adicionais do projeto
* **Margem de Contribuição:** Receita menos todos os custos
* **Margem Percentual:** (Margem / Receita) × 100
Essas métricas permitem acompanhar a rentabilidade projeto a projeto, mas sem visão consolidada ou análise comparativa.
### Planos Standard e AI Mode
Nos planos Standard e AI Mode, você acessa o **Relatório Financeiro completo** com recursos avançados:
* **Visão consolidada:** Todos os projetos em um único lugar
* **Gráficos interativos:** Visualização completa de KPIs e tendências
* **Todos os filtros:** Por período, projeto, cliente e arquivados
* **Modos de visualização:** Semanal, trimestral, semestral e anual
* **Gestão de contratos:** Configuração completa de contratos e custos extras
* **Análise comparativa:** Compare rentabilidade entre projetos e clientes
***
## 🎯 Boas Práticas
1. **Mantenha custos/hora atualizados:** Revisar anualmente ou quando houver mudanças salariais
2. **Registre todas as horas:** Cuide para que a equipe registre o tempo trabalhado corretamente
3. **Adicione custos extras:** Não esqueça de incluir custos indiretos (licenças, infraestrutura)
4. **Revise contratos regularmente:** Certifique-se de que os contratos refletem a realidade
5. **Analise tendências:** Foque na evolução ao longo do tempo, não apenas em números isolados
6. **Compare projetos similares:** Use os dados para precificar novos projetos com base em históricos
***
## ❓ FAQ
**Os dados financeiros são visíveis para toda a equipe?**
Não. O relatório financeiro é restrito a gestores da empresa (administradores e proprietários). Membros da equipe não têm acesso a estas informações.
**Como são calculados os custos da equipe?**
Os custos são calculados multiplicando as horas trabalhadas (registradas nos time logs) pelo custo/hora configurado para cada usuário.
**Posso ter contratos com escopos diferentes no mesmo projeto?**
Sim. Um projeto pode ter múltiplos contratos, e a receita total será a soma de todos os contratos ativos.
**O que acontece com contratos inativos?**
Contratos inativos não são considerados no cálculo da receita. Use esta opção quando um contrato for substituído ou encerrado.
**Projetos arquivados aparecem no relatório?**
Por padrão, não. Mas você pode ativar a opção "Mostrar arquivados" nos filtros para incluí-los na análise.
***
## 📚 Documentação Relacionada
* [Sprints](/sprints) - Gerencie ciclos de trabalho para análise financeira
* [Time Tracking](/time-tracking) - Registre as horas trabalhadas pela equipe
# Integração com GitHub
Source: https://docs.synkrony.ai/github-integration
Conecte seus repositórios e automatize o fluxo de trabalho
# Integração com GitHub
A integração do Synkrony com GitHub permite **automatizar atualizações de status** das tarefas com base em eventos de Pull Request, eliminando trabalho manual e garantindo que o kanban reflita sempre a situação real do desenvolvimento.
***
## Como Funciona
O Synkrony utiliza **GitHub App** e **webhooks** para monitorar eventos em seus repositórios. Quando algo relevante acontece em um Pull Request, o sistema identifica automaticamente a tarefa relacionada e atualiza seu status.
### Autenticação via GitHub App
Diferente de OAuth pessoal, o Synkrony usa **GitHub App**, que oferece:
* ✅ **Segurança aprimorada:** Credenciais compartilhadas, não tokens pessoais
* ✅ **Escopo configurável:** Acesso apenas aos repositórios necessários
* ✅ **Automação-friendly:** Ideal para integrações CI/CD
* ✅ **Gerenciamento centralizado:** Administradores controlam o acesso
***
## Vinculando Tarefas a Pull Requests
### Método 1: Slug no Título (Recomendado)
Inclua o slug da tarefa no título do PR:
* Exemplo simples: `[SW-123] Implementar autenticação`
* Múltiplas tarefas: `[SW-123] [SW-456] Atualizar API`
### Método 2: URL do PR
Se nenhum slug for encontrado, o sistema usa a URL do PR como referência.
***
## Fluxo de Automação
A seguir, o comportamento de cada evento de Pull Request:
### 📌 PR Aberto (Opened)
| Condição | Status Resultado |
| ------------------- | ---------------------------------------- |
| PR normal | Move para o status mapeado como `review` |
| PR em draft | Permanece no status atual |
| Tarefa já concluída | Não sofre alteração |
**Dados armazenados na tarefa:**
* URL do Pull Request
* Repositório GitHub
* Autor do PR
* Número do PR
* Data de criação
* Flag indicando se é draft
### 👍 PR Aprovado (Approved)
Disparado quando um revisor aprova o PR:
| Condição | Status Resultado |
| ----------------------- | ------------------------------------------ |
| Revisão aprovada | Move para o status mapeado como `approved` |
| Revisor é o autor do PR | Não sofre alteração |
| Tarefa já concluída | Não sofre alteração |
### 🔄 Alterações Solicitadas (Changes Requested)
Disparado por dois eventos:
1. **Review formal:** Revisor marca como "changes requested"
2. **Comentário de revisor:** Qualquer comentário de um revisor solicitado no PR
| Condição | Status Resultado |
| ------------------------- | ----------------------------- |
| Alterações solicitadas | Move para `changes_requested` |
| Comentário de revisor | Move para `changes_requested` |
| Comentário de não-revisor | Não sofre alteração |
### ✅ PR Mergeado (Merged)
O evento final do ciclo de vida do PR:
| Condição | Status Resultado |
| -------------------- | ------------------------------------- |
| PR mergeado | Move para `done` |
| Task Execution ativa | Marca a execução como concluída |
| Feedback ativo | Adiciona comentário de feedback no PR |
### 📝 PR Editado
Atualizações nas informações do PR:
| Alteração | Comportamento |
| ----------------- | --------------------------------------------------------- |
| Draft → Não-draft | Se o status não tem mapeamento GitHub, move para `review` |
| Não-draft → Draft | Define flag de draft |
| Outras edições | Apenas atualiza metadados |
### 🔁 PR Reaberto (Reopened)
| Condição | Status Resultado |
| ----------- | -------------------------- |
| PR reaberto | Move para `review` |
| Metadados | Atualiza informações do PR |
### ❌ PR Fechado (Closed)
| Condição | Status Resultado |
| ------------------------- | --------------------------------- |
| PR fechado (não mergeado) | **Não sofre alteração de status** |
> **Importante:** Apenas PRs mergeados movem tarefas para "Done". PRs fechados sem merge não alteram o status.
***
## Eventos de Webhook Suportados
O Synkrony processa os seguintes eventos do GitHub:
| Evento | Descrição |
| ----------------------------- | ------------------------------------------------------------- |
| `pull_request` | Abertura, edição, fechamento, merge ou reabertura de PR |
| `pull_request_review` | Submissão de review (approved, changes\_requested, commented) |
| `pull_request_review_comment` | Comentários em linhas específicas de código |
| `issue_comment` | Comentários gerais no PR |
| `check_run` | Status de GitHub Actions |
| `installation` | Instalação/desinstalação do GitHub App |
| `installation_repositories` | Alteração de repositórios configurados |
***
## Segurança
### Validação de Webhooks
* **Assinatura HMAC:** Cada webhook é validado usando `X-Hub-Signature-256`
* **Segredo compartilhado:** Garante que apenas eventos legítimos do GitHub são processados
* **Filtro de bots:** Ignora eventos de GitHub bots para evitar loops infinitos
### Instalação por Empresa
Cada empresa pode instalar o GitHub App do Synkrony com opções:
* **Todos os repositórios:** Acesso completo à conta da organização
* **Repositórios selecionados:** Apenas aos repositórios escolhidos
***
## Configuração Passo a Passo
### 1. Acesse as Configurações
Navegue para **Configurações → GitHub**
### 2. Instale o GitHub App
Clique em **Instalar GitHub App** e escolha:
* Conta pessoal ou organização do GitHub
* Repositórios desejados (todos ou selecionados)
### 3. Configure o Mapeamento de Status
Certifique-se de que os status do Synkrony estão mapeados corretamente:
| Status do Synkrony | GitHub Status Type |
| ----------------------- | ------------------- |
| Aguardando Revisão | `review` |
| Alterações Requisitadas | `changes_requested` |
| Aprovado (se existir) | `approved` |
| Done | `done` |
***
## Exemplo Prático de Fluxo
```
1. Desenvolvedor cria tarefa "SW-123" no Synkrony
→ Status: "A Fazer"
2. Dev começa a trabalhar na tarefa
→ Move manualmente para "Em Andamento"
3. Dev cria PR draft: "[SW-123] Implementar feature"
→ Status permanece "Em Andamento" (é draft)
4. Dev marca PR como pronto para review
→ Status move automaticamente para "Aguardando Revisão"
5. Revisor aprova o PR
→ Status move automaticamente para "Aprovado"
6. Revisor solicita alterações via review
→ Status move automaticamente para "Alterações Requisitadas"
7. Dev faz ajustes e solicita novo review
→ Status move automaticamente para "Aguardando Revisão"
8. PR é mergeado
→ Status move automaticamente para "Done"
→ Comentário de feedback é adicionado no PR
```
***
## Comportamentos Especiais
### Draft PRs
Pull Requests em draft **não** movem tarefas para review. Eles permanecem no status atual (geralmente "Em Andamento") até que sejam marcados como prontos para review.
> A PR é considerada draft se o título contém "\[draft]" ou "draft"
### Múltiplas Tarefas em um PR
Um único PR pode referenciar múltiplas tarefas incluindo vários slugs no título:
```
[SW-123] [SW-456] Feature completa com backend e frontend
```
Todas as tarefas mencionadas serão atualizadas simultaneamente.
***
## ❓ FAQ
**Posso ter múltiplos status com o mesmo github\_status\_type?**
Não. Por empresa, apenas um status pode ter cada tipo de mapeamento GitHub. Isso garante clareza na automação.
**O que acontece se eu não configurar os mapeamentos GitHub?**
O Synkrony já vem com status pré-configurados. Você pode personalizá-los, mas não é obrigatório para o funcionamento básico.
**PRs de draft afetam o status da tarefa?**
Não. PRs em draft não movem a tarefa para "Review", ela permanece no status atual.
**O que acontece se eu fechar um PR sem merge?**
A tarefa NÃO move para "Done". Ela permanece no status atual, permitindo que você decida o próximo passo manualmente.
**Como desconectar um PR de uma tarefa?**
Atualmente não é possível desconectar. Edite o título do PR removendo o slug ou crie um novo PR.
**A integração funciona com repositórios privados?**
Sim! O GitHub App funciona com repositórios públicos e privados, desde que devidamente configurado.
**Posso usar a integração sem ter os status configurados?**
Sim, mas a automação não funcionará corretamente. Certifique-se de configurar pelo menos os status de `review`, `changes_requested` e `done`.
***
## Troubleshooting
### O PR não está movendo a tarefa
Verifique:
1. O slug da tarefa está no título do PR?
2. O status de destino está configurado com o `github_status_type` correto?
3. O repositório está configurado no GitHub App?
### A tarefa moveu para o status errado
Verifique:
1. Os mapeamentos de `github_status_type` estão corretos?
2. Há múltiplos status com o mesmo mapeamento?
### Eventos não estão sendo processados
Verifique:
1. O GitHub App está instalado na organização correta?
2. O repositório tem permissão para enviar webhooks?
# Importação de Tarefas
Source: https://docs.synkrony.ai/importacao-tarefas
Migre seus projetos de outras ferramentas como Asana, ClickUp, Jira e Linear
A **Importação de Tarefas** permite que você migre facilmente seus projetos de outras ferramentas de gerenciamento para o Synkrony. Com suporte para planilhas CSV e XLSX exportadas de Asana, ClickUp, Jira, Linear e outros, você pode trazer suas tarefas, projetos, tags e responsáveis em poucos minutos.
Acesse a importação através do menu lateral: **Configurações → Importação**.
***
## 🔄 Como Funciona
O processo de importação é realizado em 3 etapas simples:
1. **Upload do Arquivo:** Envie sua planilha (.CSV ou .XLSX) exportada da ferramenta de origem
2. **Mapeamento de Campos:** Associe as colunas da planilha aos campos do sistema
3. **Preview e Confirmação:** Revise os dados, mapeie os status e confirme a importação
### Softwares Suportados
| Software | Formatos | Observações |
| ----------------------- | -------- | ------------------------------------------ |
| **ClickUp** | CSV/XLSX | Suporte completo a campos customizados |
| **Asana** | CSV/XLSX | Mapeamento automático de projetos e seções |
| **Jira** | CSV/XLSX | Suporte a data/hora específico do Jira |
| **Linear** | CSV/XLSX | Mapeamento de labels e assignees |
| **Planilhas Genéricas** | CSV/XLSX | Qualquer planilha com estrutura compatível |
***
## 📤 Etapa 1: Upload do Arquivo
### Formatos Aceitos
* **CSV:** Separado por vírgulas, com BOM UTF-8 ou sem
* **XLSX/XLS:** Excel nativo
### Instruções por Software
#### ClickUp
1. Acesse o ClickUp
2. Vá em **List View** da sua lista/tarefas
3. Clique no menu de 3 pontos
4. Selecione **Export**
5. Escolha formato **CSV** ou **Excel**
6. Faça upload no Synkrony
#### Asana
1. Abra o projeto no Asana
2. Clique na seta ao lado do nome do projeto
3. Selecione **Export → CSV**
4. Faça upload no Synkrony
#### Jira
1. Execute a busca das tarefas que deseja exportar
2. Clique no botão **Export** no topo
3. Selecione **Excel** (current fields)
4. Faça upload no Synkrony
#### Linear
1. Abra o projeto no Linear
2. Clique em **... → Export**
3. Selecione **CSV**
4. Faça upload no Synkrony
***
## 🔗 Etapa 2: Mapeamento de Campos
Após fazer o upload, você verá uma tabela onde deve associar cada coluna da sua planilha aos campos do sistema.
### Campos do Sistema Disponíveis
| Campo | Descrição | Obrigatório |
| ------------------- | ----------------------------------------- | ----------- |
| **Nome da Tarefa** | Título da tarefa | Sim |
| **Status** | Status da tarefa (ex: TODO, Em Progresso) | Recomendado |
| **Projeto** | Projeto ao qual a tarefa pertence | Recomendado |
| **Descrição** | Detalhes da tarefa | Não |
| **Estimativa** | Tempo estimado em horas | Não |
| **Prioridade** | Nível de prioridade | Não |
| **Responsável** | Usuário atribuído | Não |
| **Etiquetas** | Tags da tarefa | Não |
| **Data de Criação** | Quando a tarefa foi criada | Não |
### Mapeamento Automático
Clique em **"Mapear automaticamente"** para que o sistema identifique as colunas baseado em padrões conhecidos:
* **ClickUp:** Task Name, Status, List Name, Time Estimated, Tags
* **Asana:** Name, Projects, Section/Column, Created At
* **Jira:** Nome do Projeto, Estimativa Original, Resumo, Criado
* **Linear:** Title, Project, Labels, Assignee, Created
***
## 👁️ Etapa 3: Preview e Confirmação
Nesta etapa final, você pode revisar todos os dados antes de confirmar a importação.
### Abas Disponíveis
#### Tarefas
Visualize as primeiras 20 tarefas que serão importadas com seus campos mapeados.
#### Projetos
* Revise todos os projetos detectados na importação
* **Remova** projetos que não deseja importar clicando no ícone **X**
* **Restaure** projetos clicando no ícone de desfazer
* Tarefas sem projeto identificado serão atribuídas ao **"Projeto Padrão"**
#### Etiquetas
Visualize todas as tags que serão criadas automaticamente.
#### Usuários
Visualize os responsáveis detectados. Usuários serão criados com emails temporários caso não existam.
#### Status
**Importante:** Associe os status do software original aos status do seu Kanban no Synkrony.
1. Clique em **"Mapear automaticamente"** para tentar mapear status comuns
2. Para cada status da planilha, selecione o status correspondente do sistema
3. Status não mapeados resultarão em tarefas sem status definido
| Status Original | Status do Sistema |
| --------------- | ----------------- |
| Todo | TODO |
| In Progress | IN PROGRESS |
| Complete | DONE |
***
## ⚙️ Comportamentos Especiais
### Cores Automáticas
* **Projetos** recebem cores automáticas de uma paleta pré-definida
* **Tags** recebem cores em ordem inversa para variedade visual
* Você pode editar cores posteriormente em **Configurações → Projetos**
### Tratamento de Estimativas
* Estimativas em **milissegundos** (ClickUp) são convertidas para horas
* Estimativas em **segundos** são convertidas para horas
* Valores menores que 1 hora são arredondados para 1 hora
* Valores maiores são arredondados para cima
### Formatos de Data
O sistema reconhece automaticamente formatos de diferentes softwares:
* **Jira:** `06/May/24 02:30 PM`
* **Asana:** `2024-05-06`
* **ClickUp:** `05/06/2024, 14:30:00 PM`
* **Linear e outros:** Formato ISO ou padrão do sistema
### Múltiplos Valores
* **Tags:** Múltiplas tags separadas por vírgula: `[bug, frontend, urgente]`
* **Responsáveis:** Múltiplos assignees separados por vírgula
***
## 🔙 Reversão de Importação
Caso precise desfazer uma importação:
1. Acesse **Configurações → Importação**
2. Vá para a aba **Histórico de Importação**
3. Clique no menu de 3 pontos da importação desejada
4. Selecione **"Reverter importação"**
5. Confirme a operação
> A reversão é assíncrona. Todos os projetos, tarefas, tags e usuários criados pela importação serão removidos, incluindo dados relacionados como time logs e comentários.
***
## 🎯 Dicas e Boas Práticas
1. **Revise o preview cuidadosamente:** Verifique especialmente status e projetos antes de confirmar
2. **Mapeie todos os status:** Tarefas sem status podem ficar perdidas no kanban
3. **Use projetos existentes:** Se você já tem projetos criados, mantenha os nomes idênticos para reutilizar
4. **Limpe os dados:** Antes de exportar, remova tarefas que não deseja migrar
5. **Teste com pequenos volumes:** Faça uma importação de teste com poucas tarefas primeiro
6. **Verifique estimativas:** Confirme se as horas estimadas foram convertidas corretamente
7. **Configure usuários:** Após importar, atualize os emails temporários dos usuários
***
## ❓ FAQ
**Posso importar do Trello?**
Sim! Exporte seu Trello para CSV e faça a importação seguindo os mesmos passos.
**O que acontece com tarefas duplicadas?**
O sistema não detecta duplicatas automaticamente. Se você fizer a importação duas vezes, terá tarefas duplicadas. Use a reversão para remover a segunda importação.
**Posso editar tarefas após a importação?**
Sim, todas as tarefas importadas podem ser editadas normalmente no kanban.
**Os usuários importados recebem notificação?**
Não. Usuários criados automaticamente recebem emails temporários e não são notificados. Você deve editar e convidar os membros da equipe posteriormente.
**Posso fazer múltiplas importações?**
Sim! Você pode importar de múltiplas fontes. Cada importação fica salva no histórico e pode ser revertida independentemente.
**O limite de tarefas por importação?**
O preview mostra as primeiras 20 tarefas, mas a importação processa todo o arquivo. Arquivos muito grandes podem demorar mais para serem processados.
***
## 📚 Documentação Relacionada
* [Status do Kanban](/status) - Configure os status disponíveis no seu fluxo
* [Projetos](/projects) - Gerencie os projetos da sua empresa
* [Sprints](/sprints) - Organize o trabalho em ciclos produtivos
# Introdução ao Synkrony
Source: https://docs.synkrony.ai/introducao
A primeira ferramenta de gestão de projetos que escreve código para você
# Synkrony
O Synkrony é uma plataforma de gerenciamento de projetos com **IA que escreve código**. Diferente do Jira, Linear ou Trello, o Synkrony une planejamento de Sprint com execução automática via IA — você descreve a tarefa, o Kanbino planeja, codifica e abre o PR.
***
## 🎯 O Problema que Resolvemos
A troca de contexto entre ferramentas de planejamento e execução consome até **40% do tempo dos desenvolvedores**.
| Forma Antiga | Synkrony |
| ---------------------------------- | ----------------------------------- |
| Jira/Linear (planejamento isolado) | Planejamento + Execução integrados |
| VS Code (execução manual) | PRs automáticos via Kanbino |
| Context switching constante | Contexto automático e execução real |
***
## 🤖 Como Funciona
### Do Card ao PR em Minutos
O Kanbino entende o contexto do seu código e transforma tarefas em Pull Requests automaticamente:
1. **Descreva a tarefa** - Crie um card no quadro com a descrição do que precisa ser feito
2. **IA analisa o código** - O Kanbino pesquisa arquitetura, dependências e padrões do seu projeto
3. **Implementa e testa** - A IA escreve o código seguindo seus padrões e roda os testes
4. **PR pronto para review** - Uma Pull Request é gerada automaticamente no GitHub
### Engenharia de Contexto com Controle Humano
Antes de qualquer linha de código, o agente segue um ciclo rigoroso de 3 etapas:
**01. Pesquisa**
Estudo detalhado do seu código: arquitetura, dependências, padrões existentes e contexto do projeto.
**02. Planejamento**
Um plano de implementação detalhado é criado. Você revisa e aprova cada etapa antes de qualquer código ser escrito.
**03. Execução**
Uma vez aprovado, a execução do código é realizada de forma autônoma. Ao final, uma Pull Request é gerada para sua revisão.
> Você atua como **arquiteto**, não como digitador. A diferença é orquestração vs. autocompletar.
***
## ⚡ Paralelização de Agentes
Controle seus agentes da mesma forma que controla seus humanos. Múltiplas tarefas executadas simultaneamente com total visibilidade.
* **5x** mais tarefas em paralelo
* **100%** controle humano garantido
* **24/7** agentes sempre disponíveis
Enquanto você revisa um plano de arquitetura, outros agentes já estão codificando tasks aprovadas. É como gerenciar um time distribuído, mas sem gargalos humanos.
***
## 🔧 Tech Stack Agnóstico
Funciona com qualquer stack. O Synkrony é agnóstico e se conecta diretamente ao seu repositório e às suas ferramentas de CI/CD.
| Repositórios | Linguagens | Frameworks | Cloud |
| ------------ | ---------- | ---------- | ------ |
| GitHub | JavaScript | React | AWS |
| GitLab | TypeScript | Node.js | Docker |
| | Python | Django | |
| | Go | Spring | |
| | Java | | |
Se você usa Git e tem testes automatizados, a plataforma funciona.
***
## 🛡️ Segurança e Privacidade
* Seu código **permanece no seu repositório** — não armazenamos, não treinamos modelos com seus dados
* Toda execução gera uma Pull Request **isolada** — se algo não estiver correto, você rejeita o PR
* O código passa pelos seus **testes automatizados** antes de chegar até você
* Setup em minutos, sem migração de código ou mudança de ferramentas
***
## 💡 IA + Gestão Integrada
Enquanto o Kanbino escreve código, o Synkrony oferece uma plataforma completa de gestão:
* **Quadro dedicado para humanos** — com Sprints completas, gestão de tempo integrada e automação de status
* **Time Tracking invisível** — tempo rastreado automaticamente
* **Relatórios de performance e financeiro** — métricas do time e rentabilidade dos projetos
* **Gerencie humanos e IAs na mesma plataforma**
***
## 📊 Planos
Um plano para cada fase do seu time:
| Plano | Para quem | Preço | Destaques |
| ---------------- | ------------------------------------- | ------------------- | --------------------------------------- |
| **Free Forever** | Times pequenos começando | R\$ 0 | 150 tarefas/mês, 2 execuções AI grátis |
| **Standard** | Equipes que precisam de flexibilidade | R\$ 44,90/user/mês | Tarefas ilimitadas, relatórios |
| **AI Mode** | Automação com IA | R\$ 119,90/user/mês | 30 execuções de task, até 3 em paralelo |
| **Enterprise** | Grandes times e empresas | Consultar | Créditos ilimitados, suporte dedicado |
Comece grátis, sem cartão de crédito. Setup em minutos.
***
## 🚀 Comece Agora
Sua próxima sprint 40% mais rápida. Delegue tarefas ao Kanbino e foque no que realmente importa: arquitetura, code review e decisões de produto.
[Criar conta grátis](https://app.synkrony.ai) — [Agendar demonstração](https://vsl.synkrony.ai)
***
## 📚 Próximos Passos
* [Como funcionam os Sprints](/sprints) - Organize o trabalho em ciclos produtivos
* [Status do Kanban](/status) - Configure as colunas e pontuações do quadro
* [Integração com GitHub](/github-integration) - Conecte suas tarefas com Pull Requests
* [Modo AI](/ai-mode) - Configure o Kanbino para executar tarefas automaticamente
* [Kanbino](/kanbino) - Entenda como a IA escreve código para você
# Kanbino - Agente de IA
Source: https://docs.synkrony.ai/kanbino
O motor de inteligência artificial do Modo AI
# Kanbino - O Motor de IA do Synkrony
**Kanbino** é o agente de IA que alimenta o Modo AI do Synkrony. Ele combina o poder do Claude da Anthropic com uma arquitetura especializada para entender sua codebase, planejar implementações e executar tarefas de desenvolvimento de forma autônoma.
> Para habilitar essa funcionalidade entre em contato com o time comercial
***
## Como o Kanbino Funciona
O Kanbino opera através de um pipeline bem definido que transforma descrições de tarefas em código pronto para produção:
```
Descrição → Análise → Planejamento → Revisão → Execução → Pull Request → Feedback
```
### Componentes Principais
#### 1. Pipeline de Execução
O **PipelineJob** orquestra todo o fluxo:
* Gerencia as transições de estado
* Coordena os jobs de planejamento e execução
* Lida com erros e retentativas
* Rastreia o progresso em tempo real
#### 2. Análise de Contexto
Antes de começar, o Kanbino analisa seu projeto:
* **Estrutura de arquivos:** Entende a organização do código
* **Padrões e convenções:** Detecta estilo de código, nomenclatura
* **Dependências:** Identifica libraries e frameworks utilizados
* **Histórico de commits:** Aprende com o padrão de commits da equipe
#### 3. Motor de Planejamento
O **PlanJob** gera o plano de implementação:
* Analisa o requisito da tarefa
* Propõe uma estratégia de implementação
* Lista arquivos que serão modificados/criados
* Identifica possíveis pontos de atenção
#### 4. Motor de Execução
O **ExecuteJob** implementa o código:
* Segue o plano aprovado passo a passo
* Lê e escreve arquivos
* Executa comandos do projeto (testes, linters)
* Cria commits organizados
* Gera Pull Request completo
***
## Ciclo de Vida de uma Execução
Toda execução do Kanbino passa por estados bem definidos:
### Estados de Execução
```
pending → planning → waiting_plan_approval → executing → pr_created → done
↑ ↓
└── replanning ← waiting_user_changes
```
| Estado | Descrição |
| ------------------------ | ------------------------------------------ |
| `pending` | Tarefa criada, aguardando início |
| `planning` | IA está gerando o plano de implementação |
| `waiting_plan_approval` | Plano pronto, aguardando sua revisão |
| `waiting_user_changes` | IA aguardando seu feedback sobre o plano |
| `replanning` | IA está revisando o plano com seu feedback |
| `executing` | IA está implementando as mudanças |
| `pr_created` | Pull Request foi criado |
| `done` | Tarefa concluída |
| `blocked` | Execução bloqueada (requer intervenção) |
| `canceled` | Execução cancelada pelo usuário |
| `awaiting_user_response` | IA aguardando resposta a uma pergunta |
***
## Fluxo de Revisão
A revisão é o coração do Kanbino. É onde você garante qualidade e direcionamento antes que a IA comece a implementar.
### Revisão via Interface Synkrony
A forma principal de interação é através do **dialog do Kanbino** no Synkrony:
#### 1. Chat em Tempo Real
Durante todo o processo, você conversa com a IA através de um chat:
* **Mensagens da IA:** A IA explica o que está fazendo
* **Perguntas da IA:** A IA faz perguntas para esclarecer requisitos
* **Suas respostas:** Você pode responder, pedir alterações ou aprovar
#### 2. Revisão do Plano
Quando o plano está pronto, você pode:
* ✅ **Confirmar:** Aprovar o plano e iniciar execução
* 🔄 **Pedir alterações:** Solicitar mudanças no plano
* ❓ **Fazer perguntas:** Esclarecer pontos do plano
#### 3. Acompanhamento da Execução
Durante a execução, você vê em tempo real:
* Arquivos sendo lidos e modificados
* Comandos sendo executados
* Saída dos comandos (testes, linters)
* Progresso das etapas
### Revisão via GitHub
Após a execução, o Pull Request é criado no GitHub para revisão padrão:
#### Pull Request Automático
O PR criado pela IA inclui:
* **Título:** Formato `[SW-123] Descrição da tarefa`
* **Descrição:** Explicação das mudanças realizadas
* **Commits:** Organizados por etapa do plano
* **Arquivos:** Todas as modificações criadas/novas
#### Fluxo de Code Review
1. **Revise as mudanças** como faria com qualquer PR
2. **Comente** sugestões ou correções necessárias
3. **Solicite alterações** se precisar de ajustes
4. **Aprove** quando estiver satisfeito
> Importante: O PR passa pelo mesmo processo de revisão que qualquer PR criado por um humano.
***
## Sistema de Perguntas e Respostas
Durante o planejamento, o Kanbino pode fazer perguntas para entender melhor o requisito:
### Quando a IA Faz Perguntas
* Requisitos ambíguos ou incompletos
* Múltiplas abordagens possíveis
* Decisões que dependem de preferências da equipe
* Pontos que não estão claros na descrição
### Como Responder
Responda no chat do Kanbino:
* **Respostas diretas:** "Prefiro usar React Query em vez de useState"
* **Esclarecimentos:** "O campo deve ser obrigatório apenas se o usuário selecionar a opção X"
* **Exemplos:** "O comportamento deve ser similar ao formulário de criação de projeto"
### Impacto no Plano
Suas respostas ajudam a IA a:
* Refinar a abordagem técnica
* Definir melhor os requisitos
* Evitar mal-entendidos
* Criar um plano mais preciso
***
## Feedback e Melhoria Contínua
O Kanbino aprende com feedback para melhorar continuamente.
### Feedback Pós-Execução
Após o merge do PR, você pode avaliar o trabalho:
#### Avaliação por Estrelas
| Avaliação | Quando Usar |
| --------- | ------------------------------------------------------------ |
| ⭐⭐⭐⭐⭐ | Tudo funcionou perfeitamente, nenhum ajuste necessário |
| ⭐⭐⭐⭐ | Pequenos ajustes feitos, trabalho de qualidade |
| ⭐⭐⭐ | Algumas correções necessárias, mas abordagem correta |
| ⭐⭐ | Revisão extensa necessária, abordagem parcialmente incorreta |
| ⭐ | Não funcionou, abordagem incorreta |
#### Comentários Textuais
Além das estrelas, você pode deixar comentários:
* O que funcionou bem
* O que pode ser melhorado
* Problemas específicos encontrados
* Sugestões para o futuro
### Como o Feedback é Usado
* **Análise de padrões:** Identificamos casos onde a IA performa bem ou mal
* **Ajustes de prompt:** Melhoramos as instruções dadas à IA
* **Treinamento:** Feedbacks são usados para calibrar o sistema
* **Métricas de qualidade:** Acompanhamos satisfação ao longo do tempo
***
## Interação com o GitHub
O Kanbino se integra profundamente com o GitHub:
### Antes da Execução
* Lê o repositório para entender o código
* Analisa histórico de commits
* Estuda padrões da equipe
### Durante a Execução
* Executa comandos do projeto (testes, linters)
* Cria branches e commits
* Aplica mudanças no código
### Após a Execução
* Cria Pull Request automaticamente
* Adiciona comentários no PR
* Sincroniza status com o Synkrony
### Integração com Webhooks
Eventos do GitHub são processados para:
* Atualizar status da tarefa no Synkrony
* Coletar feedback de revisão
* Detectar merge do PR
* Disparar solicitações de feedback
***
## Tratamento de Erros
O Kanbino possui mecanismos robustos de tratamento de erros:
### Tipos de Erro
| Tipo | Descrição | Recuperação |
| --------------------- | ---------------------- | -------------------- |
| **Erro transitório** | Falha de rede, timeout | Tentativa automática |
| **Erro de validação** | Plano reprovado | Requer intervenção |
| **Erro de execução** | Comando falhou | Tentativa com ajuste |
| **Erro crítico** | Falha irrecuperável | Marca como blocked |
### Recuperação Automática
* **Retentativas:** Erros transitórios são automaticamente re-tentados
* **Ajuste de estratégia:** A IA tenta alternativas quando comandos falham
* **Retomada:** Execução pode ser retomada do ponto de falha
### Intervenção Manual
Quando a recuperação automática não é possível:
* Execução é marcada como `blocked`
* Você pode revisar o erro
* Retomar a execução manualmente
* Ou cancelar e tentar novamente
***
## Boas Práticas para Desenvolvedores
### Para Obter Melhores Resultados
1. **Descrições detalhadas:** Quanto mais contexto, melhor
2. **Tarefas focadas:** Divida trabalho grande em tarefas menores
3. **Revisão atenta:** Dedique tempo à revisão do plano
4. **Feedback honesto:** Avalie o trabalho da IA de forma justa
5. **Pacotes de execução:** Execute tarefas similares em lote
### Durante a Revisão
1. **Verifique a compreensão:** A IA entendeu o requisito?
2. **Valide a abordagem:** A estratégia técnica faz sentido?
3. **Confirme os arquivos:** Os arquivos listados estão corretos?
4. **Revise as etapas:** O plano está completo?
### Durante o Code Review
1. **Revise como qualquer PR:** Não dê tratamento especial por ser IA
2. **Teste o código:** Execute e valide as mudanças
3. **Comente construtivamente:** Ajude a IA a aprender
4. **Solicite alterações quando necessário:** Não aprove se não estiver bom
***
## Segurança e Isolamento
O Kanbino foi projetado com segurança desde o início:
### Isolamento de Execução
* Cada execução roda em ambiente isolado
* Não há interferência entre execuções simultâneas
* Recursos são limitados e controlados
### Controle de Acesso
* Apenas acessa repositórios autorizados
* Segue permissões do usuário que iniciou a tarefa
* Todas as ações são rastreadas em logs
### Transparência
* Todas as mudanças ficam no git
* Histórico completo de conversas com a IA
* Logs detalhados de execução
### Code Review Humano
* PRs sempre passam por revisão humana
* Nada é mergeado automaticamente
* Você mantém controle total
***
## Limitações Atuais
O Kanbino é poderoso, mas tem limitações:
### O que Funciona Bem
* ✅ Tarefas bem definidas e focadas
* ✅ Refatorações com escopo claro
* ✅ Implementação de features simples
* ✅ Criação de testes
* ✅ Atualizações incrementais
### Limitações Conhecidas
* ❌ Tarefas muito grandes ou complexas
* ❌ Mudanças arquiteturais significativas
* ❌ Requisitos vagos ou mal definidos
* ❌ Contexto de múltiplos repositórios
* ❌ Decisões de negócio complexas
### Melhorias Contínuas
Estamos trabalhando constantemente em:
* Melhor compreensão de contexto
* Suporte a tasks mais complexas
* Melhor recuperação de erros
* Aprendizado com feedback
***
## ❓ FAQ
**Kanbino substitui desenvolvedores?**
Não. Kanbino é uma ferramenta de produtividade que automatiza tarefas repetitivas, permitindo que desenvolvedores foquem em problemas mais complexos e criativos.
**O código gerado é seguro?**
O código passa pelo mesmo processo de code review que qualquer PR. Você tem controle total e deve revisar todas as mudanças antes do merge.
**Posso confiar nos testes gerados pela IA?**
Revise os testes como qualquer outro código. A IA segue padrões do projeto, mas você deve validar a cobertura e a qualidade.
**O que acontece se a IA travar?**
O sistema detecta execuções travadas e permite retomar ou cancelar. Timeout padrão é de 30 minutos.
**Posso executar múltiplas tarefas simultaneamente?**
Sim, dependendo do seu plano. Cada execução é independente e isolada.
**A IA aprende com meus projetos?**
Sim, o Kanbino analisa seu código para entender padrões, convenções e contexto. Esse conhecimento é usado apenas nas suas execuções.
***
## Suporte
Precisa de ajuda com o Kanbino?
* **Documentação do usuário:** Consulte o guia [Modo AI](/ai-mode)
* **Email:** [suporte@synkrony.com.br](mailto:suporte@synkrony.com.br)
* **Chat:** Disponível na plataforma (Standard, AI Mode e Enterprise)
O Kanbino está em constante evolução. Novas funcionalidades e melhorias são lançadas regularmente baseadas em feedback dos usuários.
# Model Context Protocol (MCP)
Source: https://docs.synkrony.ai/model-context-protocol
O Model Context Protocol é uma forma organizada de estruturar as informações que enviamos para modelos de linguagem (LLMs), permitindo que nos comuniquemos de maneira mais eficiente e consistente.
Ele funciona como se fosse uma API para LLMs.
O Synkrony utiliza o **SDK oficial do Ruby para MCP** ([modelcontextprotocol/ruby-sdk](https://github.com/modelcontextprotocol/ruby-sdk)), mantido oficialmente pela Anthropic e Shopify.
## Ideação para o Synkrony
A ideia é que você consiga, por meio da sua LLM predileta, organizar e obter informações de um projeto no Synkrony de maneira mais eficiente.
## Como usar?
### 1. Criar uma chave de API
Primeiro, crie uma chave de API seguindo o guia de [Configuração de Tokens de API](/configuracao-api-token).
### 2. Configurar o MCP
Escolha uma das opções abaixo para conectar o MCP do Synkrony com sua LLM:
#### Opção A: Claude Code (Recomendado)
Para produção, use o endpoint de produção:
```bash theme={null}
claude mcp add --scope user --transport http synkrony https://app.synkrony.ai/mcp/messages --header "Authorization: Bearer SEU-TOKEN-AQUI"
```
#### Opção B: Windsurf / Cursor
Crie ou edite o arquivo `mcp_config.json`:
```json theme={null}
{
"mcpServers": {
"synkrony": {
"transport": {
"type": "http",
"url": "https://app.synkrony.ai/mcp/messages",
"headers": {
"Authorization": "Bearer SEU-TOKEN-AQUI"
}
}
}
}
}
```
**Endpoint MCP:** `POST https://app.synkrony.ai/mcp/messages`
## Recursos e Ferramentas Disponíveis
O MCP do Synkrony oferece dois tipos de capacidades:
### Resources (Dados que podem ser lidos)
#### Team Resource
* **URI:** `synkrony://team`
* **Descrição:** Lista todos os membros ativos da equipe disponíveis para atribuição de tarefas
* **Filtros:** `page`, `limit` (paginação)
#### Tasks Resource
* **URI:** `synkrony://tasks`
* **Descrição:** Lista e filtra tarefas com ordenação inteligente e sugestões de próximas ações
**Filtros disponíveis via Query String:**
* `user_name` - Filtrar por responsável
* `sprint_name` - Filtrar por sprint
* `project_name` - Filtrar por projeto
* `project_module_name` - Filtrar por módulo do projeto
* `status_name` - Filtrar por status
* `task_summary` - Buscar por texto no nome da tarefa
* `next_tasks_only` - Apenas tarefas da sprint atual em andamento
* `future_sprint_task` - Apenas tarefas de sprints futuras
* `only_important` - Apenas tarefas com prioridade alta
* `order_by` - Ordenar por: `priority`, `created_at`, `updated_at`, `position`, `name`
* `order_direction` - Direção: `asc` ou `desc`
* `page`, `limit` - Paginação
**Exemplos de uso com Query String:**
```
# Filtrar por sprint específica
synkrony://tasks?sprint_name=Sprint%201677
# Filtrar por projeto e status
synkrony://tasks?project_name=Synkrony&status_name=Done
# Apenas tarefas importantes da sprint atual
synkrony://tasks?next_tasks_only=true&only_important=true
# Buscar por texto no nome
synkrony://tasks?task_summary=MCP
# Ordenar por prioridade descendente
synkrony://tasks?order_by=priority&order_direction=desc
```
**Resource Templates Disponíveis:**
O servidor também expõe Resource Templates para consultas comuns. Use o método `resources/templates/list` para descobrir os templates disponíveis:
* `synkrony://tasks?sprint_name={sprint_name}` - Filtrar por sprint
* `synkrony://tasks?project_name={project_name}` - Filtrar por projeto
* `synkrony://tasks?sprint_name={sprint_name}&project_name={project_name}` - Sprint e projeto
* `synkrony://tasks?next_tasks_only=true` - Tarefas da sprint atual
* `synkrony://tasks?status_name={status_name}` - Filtrar por status
* `synkrony://tasks?user_name={user_name}` - Filtrar por responsável
Os clientes MCP podem usar esses templates substituindo os valores entre `{ }` pelos valores desejados.
### Tools (Ações que podem ser executadas)
#### CreateTasksTool
* **Uso:** `create_tasks` - Cria novas tarefas
* **Parâmetros:**
* `name` (obrigatório) - Nome da tarefa
* `project_name` (obrigatório) - Nome do projeto
* `description` - Descrição da tarefa
* `sprint_name` - Nome da sprint
* `project_module_name` - Nome do módulo do projeto
* `status` - Status: `Backlog`, `Ongoing`, `Done`
* `priority` - Prioridade: `high`, `medium`, `low`
* `estimate` - Estimativa em horas (não pode ser zero ou negativo)
* `assignee_names` - Array de nomes dos responsáveis: `["João Silva", "Maria Santos"]`
* `tags` - Array de tags: `["frontend", "urgente"]`
#### EditTasksTool
* **Uso:** `edit_tasks` - Edita tarefas existentes
* **Parâmetros:**
* `id` (obrigatório) - ID da tarefa a editar
* Mesmos parâmetros do `CreateTasksTool`, mas todos são opcionais exceto `id`
## Agente de Planejamento de Tarefas
Nosso MCP foi criado com o intuito de facilitar o planejamento de tarefas na sprint via chatbot. A ideia é que, em breve, teremos uma interface integrada à plataforma, mas por enquanto é possível escrever um prompt para planejar a sprint:
```markdown theme={null}
Você é um assistente que ajuda a planejar sprints para equipes de software usando o Synkrony.
O usuário irá descrever suas necessidades em linguagem natural.
Você deve extrair os seguintes campos da conversa:
- sprint_name (nome da sprint)
- team: lista de pessoas que serão alocadas nas tarefas, suas áreas de foco e sua capacidade em horas na sprint
- priority_areas (qual será o foco da equipe nesta sprint)
## Recursos e Ferramentas MCP Disponíveis
Use os seguintes recursos e ferramentas do Synkrony para o planejamento de sprints:
### 1. Team Resource
- **URI**: `synkrony://team`
- **Uso**: Leia este recurso para obter a lista de todos os membros ativos da equipe disponíveis para atribuição de tarefas
- **Filtros**: `page`, `limit` (para paginação)
### 2. Tasks Resource
- **URI**: `synkrony://tasks`
- **Uso**: Leia este recurso para listar e filtrar tarefas existentes
- **Filtros úteis**:
- `sprint_name` - Filtrar por sprint específica
- `project_name` - Filtrar por projeto
- `user_name` - Filtrar por responsável
- `status_name` - Filtrar por status
- `next_tasks_only` - Apenas tarefas em andamento da sprint atual
### 3. CreateTasksTool
- **Uso**: Chame esta ferramenta para criar novas tarefas com nome, descrição, projeto, sprint, responsáveis, estimativas e tags
### 4. EditTasksTool
- **Uso**: Chame esta ferramenta para editar tarefas existentes (requer ID da tarefa) para atualizar qualquer campo
## Processo de Planejamento
1. Seu primeiro objetivo é completar o JSON com a estrutura de resposta:
- **Comece lendo o recurso `synkrony://team`** para obter a equipe disponível.
- **Leia o recurso `synkrony://tasks`** com filtros apropriados para ver as tarefas existentes do projeto/sprint.
- Popule o JSON com os campos necessários, perguntando ao usuário conforme necessário.
2. Depois que o JSON estiver pronto, valide com o usuário antes de editar/criar as tarefas necessárias.
3. Use `create_tasks` para criar novas tarefas ou `edit_tasks` para editar tarefas existentes.
## Estrutura do JSON
{
"ready": true,
"sprint_name": "Nome da Sprint",
"team": [
{"name": "Nome", "hours_per_person": "X", "skill_focus": "Área"},
...
],
"priority_areas": ["Área1", "Área2", ...]
}
## Regras Adicionais
- Priorize tarefas com um único responsável sempre que possível.
- Permita, no máximo, dois responsáveis por tarefa.
- Use os nomes das sprints do Synkrony para manter a consistência.
- Sempre verifique tarefas existentes antes de criar novas.
- Mantenha as estimativas realistas, baseadas na capacidade da equipe.
```
# Relatório de Performance do Time
Source: https://docs.synkrony.ai/performance-report
Acompanhe a evolução da performance da equipe através das sprints
O **Relatório de Performance do Time** é uma ferramenta essencial para gestores que desejam acompanhar a evolução da equipe ao longo das sprints. Através de métricas individuais e coletivas, você obtém insights valiosos sobre a produtividade e a eficiência do time de desenvolvimento.
Acesse o relatório através do menu lateral: **Relatórios → Performance do time**.
***
## 📊 Como Funciona
Ao final de cada sprint, o Synkrony gera automaticamente um relatório de performance para cada participante. O relatório considera:
* **Story Points Planejados:** Total de pontos atribuídos às tarefas do membro na sprint
* **Story Points Entregues:** Pontos das tarefas concluídas (status "Done")
* **Pontos em Andamento:** Pontos de tarefas que estão em progresso
* **Taxa de Conclusão:** Percentual de pontos entregues em relação ao planejado
* **Eficiência:** Métrica que considera a pontuação ponderada de cada status das tarefas
* **Capacidade:** A performance pode ser medida em relação a capacidade do membro naquela Sprint
***
## ⚙️ Configuração do Relatório
As configurações do relatório de performance são acessadas através de **Configurações → Relatório de Performance**.
> **Nota:** Por questões de segurança, estas configurações são restritas aos **administradores** da empresa.
### Meta de Sprint (Performance Goal)
Defina o objetivo de completion rate (taxa de conclusão) que a equipe deve atingir. Esta meta é usada como referência nos gráficos de performance.
* **Opções disponíveis:** 60%, 65%, 70%, 75%, 80%, 85%, 90%, 95%, 100%
* **Padrão:** 90%
Esta meta representa a porcentagem de story points planejados que esperamos que sejam entregues ao final da sprint.
### Pontuação Personalizada (Custom Scoring)
Personalize quanto cada status do kanban vale no cálculo da eficiência. Isso permite adaptar o relatório ao fluxo de trabalho específico da sua equipe.
* **Status tipo "Done":** Automaticamente valem **100%** (não é alterável)
* **Demais status:** Configuráveis de 0% a 100%
* **Status tipo "Backlog":** Não participam do cálculo
**Exemplo prático:**
* Concluído: 100%
* Code Review: 80%
* Em Desenvolvimento: 50%
* A Fazer: 0%
> A eficiência é calculada somando-se os pontos ponderados de cada tarefa e dividindo pelo total de pontos possíveis.
### Participantes
Selecione quais membros da equipe devem participar do relatório de performance. Você pode incluir ou excluir membros a qualquer momento.
* **Contador visual:** Mostra quantos membros estão ativos no relatório (ex: "5/8")
* **Filtro automático:** Clientes não aparecem na lista de participantes
* **Alteração em tempo real:** Ao ativar/desativar um participante, os relatórios futuros serão afetados
***
## 🔄 Filtros e Visualização
### Filtros por Período
Selecione o período que deseja analisar:
* **Sprint Anterior:** Mostra apenas a sprint finalizada imediatamente antes da data atual
* **Últimas 2:** Mostra as 2 últimas sprints concluídas
* **Últimas 3:** Mostra as 3 últimas sprints concluídas
* **Período Personalizado:** Selecione datas específicas ou use atalhos (Este Mês, Este Trimestre, Este Semestre, Este Ano)
### Filtros por Equipe
Refine os dados por pessoas e grupos:
* **Usuários:** Filtre por membros específicos da equipe
* **Equipes:** Filtre por grupos de equipe previamente configurados
> Os filtros podem ser combinados para obter visões específicas (ex: "Performance da Equipe Backend nas últimas 2 sprints")
***
## 💰 Diferenças Entre Planos
O acesso às funcionalidades do Relatório de Performance varia conforme o plano da sua empresa:
### Plano Free
* **Visualização limitada:** Apenas a **Sprint Anterior** está disponível
* **Filtros básicos:** Acesso aos filtros de equipe
### Planos Standard e AI Mode
* **Acesso completo:** Todas as sprints anteriores disponíveis
* **Filtros avançados:** Período personalizado, múltiplas sprints, filtros por usuários e equipes
* **Configurações completas:** Acesso a todas as configurações (meta de sprint, pontuação personalizada, participantes)
* **Relatórios detalhados:** Métricas individuais e coletivas completas
* **Exportação de dados:** Capacidade de exportar relatórios
***
## 📈 Métricas Disponíveis
### Performance Individual
Para cada membro da equipe, o relatório mostra:
* **Taxa de Conclusão:** `(Pontos Entregues / Pontos Planejados) × 100`
* **Eficiência:** Calculada com base na pontuação dos status das tarefas
* **Pontos Planejados:** Total de story points atribuídos
* **Pontos Entregues:** Pontos de tarefas com status "Done"
* **Pontos Iniciados:** Pontos de tarefas em andamento
* **Distribuição por Status:** Quantos pontos em cada coluna do kanban
### Performance Geral
* **Performance Total:** Média da performance de todos os participantes
* **Comparação com Meta:** Indicador visual de progresso em relação à meta de sprint
* **Evolução ao Longo do Tempo:** Gráficos mostrando tendências de performance
### Distribuição de Tarefas
* **Total de Tarefas:** Quantidade de tarefas por membro
* **Tarefas por Status:** Distribuição das tarefas entre as colunas do kanban
***
## 🎯 Boas Práticas
1. **Defina metas realistas:** Comece com uma meta de 70-80% e ajuste conforme a maturidade da equipe
2. **Revise a pontuação periodicamente:** Conforme o processo evolui, ajuste os valores dos status para refletir melhor o progresso real
3. **Use filtros estratégicos:** Compare períodos similares (ex: mesma equipe, mesmo tipo de projeto)
4. **Acompanhe tendências:** Foque na evolução ao longo do tempo, não apenas em números isolados
5. **Comunique com a equipe:** Use os relatórios como base para conversas construtivas sobre melhorias
***
## ❓ FAQ
**Com que frequência os relatórios são atualizados?**
Os relatórios são gerados automaticamente ao final de cada sprint. Relatórios de sprints passados não são alterados.
**O que acontece com membros desativados da empresa?**
Seus relatórios históricos são mantidos, mas eles não aparecem mais como opção nos filtros de participantes.
# Planos e Preços
Source: https://docs.synkrony.ai/planos
Conheça os planos disponíveis e escolha o ideal para sua equipe
# Planos e Preços
O Synkrony oferece planos flexíveis projetados para crescer junto com sua Software House. Comece gratuitamente e escale conforme sua equipe evolui.
## Visão Geral dos Planos
**Ideal para times pequenos** começando seus primeiros projetos.
### Preço
* **R\$ 0,00** para sempre
### Recursos Incluídos
* ✓ Usuários ilimitados
* ✓ Projetos ilimitados
* ✓ Até **150 tarefas por mês**
* ✓ Acesso ao Time Tracking
* ✓ Automação com GitHub
* ✓ **5 GB de armazenamento total**
* ✓ **2 execuções grátis no AI MODE**
### Para Quem é Indicado
* Startups e pequenas equipes em fase inicial
* Times que estão conhecendo a plataforma
* Projetos piloto e validação de fluxo de trabalho
**Feito para equipes que precisam de mais flexibilidade** e controle.
### Preço
* **Mensal:** R\$ 44,90 por usuário/mês
* **Trimestral:** R$ 29,00 por usuário/mês (R$ 87,00/trimestre)
* **Anual:** R$ 29,00 por usuário/mês (R$ 348,00/ano)
Economize **35%** ao contratar plano anual ou trimestral!
### Tudo do Free, Mais:
* ✓ **Tarefas ilimitadas**
* ✓ **10 GB de armazenamento por usuário**
* ✓ Relatórios de performance e financeiro
* ✓ Gestão completa de times
* ✓ Criação de Documentos
* ✓ 15 dias de teste grátis
### Para Quem é Indicado
* Equipes em crescimento com volume maior de tarefas
* Times que necessitam de relatórios detalhados
* Empresas que precisam gerenciar múltiplos clientes
**Feito para equipes que precisam de automação** e relatórios completos.
### Preço
* **Mensal:** R\$ 119,90 por usuário/mês
* **Trimestral:** R$ 109,90 por usuário/mês (R$ 329,70/trimestre)
* **Anual:** R$ 99,90 por usuário/mês (R$ 1.199,40/ano)
Economize até **17%** no plano anual com poder ilimitado de IA!
### Tudo do Standard, Mais:
* ✓ **30 execuções de task por pessoa**
* ✓ **Até 3 tarefas em paralelo** (AI Mode)
* ✓ Suporte prioritário
* ✓ Acesso completo ao Kanbino (agente de IA)
### Para Quem é Indicado
* Equipes que querem automatizar tarefas repetitivas
* Times que necessitam de alta capacidade de processamento com IA
* Empresas focadas em acelerar o desenvolvimento
**Solução completa e personalizável** para grandes times e empresas.
### Preço
**Sob consulta** - Entraremos em contato para entender sua necessidade
### Tudo do AI Mode, Mais:
* ✓ **Créditos ilimitados** de AI Mode
* ✓ Suporte dedicado exclusivo
* ✓ Onboarding personalizado
* ✓ Integrações customizadas
* ✓ Logs de auditoria completos
* ✓ SLA garantido
### Para Quem é Indicado
* Grandes empresas com necessidades específicas
* Organizações que requerem compliance e auditoria
* Times que precisam de integrações personalizadas
## Comparativo Detalhado
| Recurso | Free Forever | Standard | AI Mode | Enterprise |
| --------------------- | ------------ | -------------- | --------------- | ------------- |
| **Preço mensal** | R\$ 0,00 | R\$ 44,90/user | R\$ 119,90/user | Sob consulta |
| **Usuários** | Ilimitados | Ilimitados | Ilimitados | Ilimitados |
| **Projetos** | Ilimitados | Ilimitados | Ilimitados | Ilimitados |
| **Tarefas/mês** | 150 | Ilimitadas | Ilimitadas | Ilimitadas |
| **Armazenamento** | 5 GB total | 10 GB/user | 10 GB/user | Personalizado |
| **Execuções AI Mode** | 2 totais | 3 totais | 30/user | Ilimitadas |
| **Time Tracking** | ✓ | ✓ | ✓ | ✓ |
| **GitHub Automation** | ✓ | ✓ | ✓ | ✓ |
| **Relatórios** | Básicos | Completos | Completos | Avançados |
| **Suporte** | Email | Email | Prioritário | Dedicado |
| **Trial** | - | 15 dias | 15 dias | - |
## Recursos Detalhados
### Gestão de Projetos
* **150 tarefas por mês**: Ideal para pequenos projetos
* **Projetos ilimitados**: Organize por cliente ou produto
* **Módulos**: Agrupe tarefas por funcionalidade
* **Time Tracking**: Registre tempo em cada tarefa
* **GitHub Automation**: Sincronização automática de PRs
* **Tarefas ilimitadas**: Sem restrição de volume
* **Sprints**: Ciclos de trabalho de 1-8 semanas
* **Status customizáveis**: Adapte o kanban ao seu fluxo
* **Relatórios de performance**: Métricas de evolução da equipe
* **Relatórios financeiros**: Controle de horas por cliente/projeto
* **Gestão de times**: Convide membros com diferentes papéis
* **Documentos**: Crie e compartilhe documentação
* **AI Mode**: Automatize tarefas de desenvolvimento com Kanbino
* **30 execuções de IA por usuário**: Processamento inteligente
* **3 tarefas em paralelo**: Execute múltiplas tarefas simultaneamente
* **Planejamento automático**: IA planeja e implementa features
* **Pull Requests automáticos**: PRs criados pela IA
* **Tudo do AI Mode**
* **Créditos ilimitados**: Sem restrição de execuções de IA
* **Suporte dedicado**: Atendimento personalizado
* **Onboarding personalizado**: Configuração assistida
* **Integrações customizadas**: Conecte com seus sistemas
* **Logs de auditoria**: Rastreabilidade completa
* **SLA garantido**: Disponibilidade assegurada
## Armazenamento e Limites
### Free Forever
* **5 GB compartilhados** entre todos os usuários da empresa
* Ideal para pequenas equipes com projetos iniciais
### Standard e AI Mode
* **10 GB por usuário** calculado dinamicamente
* Exemplo: 5 usuários = 50 GB totais
* Escala automaticamente conforme adiciona membros
Ao atingir **80% do limite de armazenamento**, você receberá notificações para evitar interrupções. Atingir 100% impede novos uploads até liberar espaço ou fazer upgrade.
### Cálculo de Armazenamento
O armazenamento é calculado como:
* **Planos pagos**: `10 GB × número de usuários não-clientes`
* **Plano Free**: `5 GB fixos` (não escala por usuário)
> **Usuários não-clientes** são membros da equipe que não têm role de "client" e participam ativamente do desenvolvimento.
## AI Mode (Kanbino)
### O que são Execuções de IA?
Cada execução representa uma solicitação completa ao **Kanbino**, nosso agente de IA que automatiza tarefas de desenvolvimento:
1. **Planejamento**: A IA analisa a tarefa e cria um plano de implementação
2. **Execução**: Implementa o código automaticamente
3. **Validação**: Executa testes e verificações
4. **Pull Request**: Cria um PR com as mudanças
### Limites por Plano
| Plano | Execuções | Cálculo |
| ------------ | --------- | ----------------- |
| Free Forever | 2 | Fixas por empresa |
| Standard | 3 | Fixas por empresa |
| AI Mode | 30 | Por usuário × 30 |
| Enterprise | ∞ | Ilimitadas |
### Exemplos Práticos
**Free Forever**
* 2 execuções totais por mês para toda empresa
* Ideal para testar a IA
**Standard**
* 3 execuções totais por mês para toda empresa
* Para explorar capacidades da IA
**AI Mode**
* 30 execuções por usuário por mês
* 5 usuários = 150 execuções totais
* Até 3 tarefas podem rodar em paralelo
**Execuções em paralelo**: No plano AI Mode, até 3 tarefas podem ser processadas simultaneamente pela IA, reduzindo o tempo total de entrega.
## Período de Teste
### Trial Gratuito de 15 Dias
Os planos **Standard** e **AI Mode** incluem um período de teste gratuito de 15 dias:
* Acesso completo a todos os recursos do plano
* Sem necessidade de cartão de crédito
* Cancelamento a qualquer momento
* Ao fim do trial, escolha continuar ou voltar ao plano Free
Aproveite o trial para explorar recursos como relatórios avançados, gestão de times e o poder do AI Mode sem compromisso.
## Faturamento
### Como Funciona
* **Cobrança por usuário**: Pague apenas pelos membros ativos da equipe
* **Usuários não-clientes**: Apenas membros que não têm role "client"
* **Ciclo mensal/trimestral/anual**: Escolha a periodicidade que funciona para você
* **Upgrade/Downgrade**: Altere planos a qualquer momento com ajuste proporcional
### Formas de Pagamento
* Cartão de crédito (todos os planos)
### Fatura e Gestão
* Acesso ao **portal de cobrança** para gerenciar assinatura pelo Stripe
* Faturas mensais automáticas
* Histórico completo de pagamentos
* Download de notas fiscais
## Perguntas Frequentes
### Posso mudar de plano a qualquer momento?
Sim! Você pode fazer upgrade ou downgrade a qualquer momento. Ao fazer upgrade, o valor é ajustado proporcionalmente. Ao fazer downgrade, o novo plano entra vigor no próximo ciclo.
### O que acontece se eu exceder os limites do plano Free?
Você será notificado ao atingir **80% do limite** de tarefas (120 de 150) ou armazenamento (4 GB de 5 GB). Ao atingir 100%, não poderá criar novas tarefas ou fazer uploads até fazer upgrade ou aguardar a renovação mensal.
### Os limites de tarefas reiniciam todo mês?
Sim, o contador de tarefas do plano Free reinicia no primeiro dia de cada mês. Da mesma forma, as execuções de AI Mode também resetam mensalmente.
### Como são calculados usuários para cobrança?
Apenas usuários com papel diferente de "client" são contabilizados. Clientes que apenas visualizam projetos não impactam no valor da assinatura.
### Posso cancelar a qualquer momento?
Sim, não há contrato de fidelidade. Você pode cancelar a qualquer momento e continuará tendo acesso até o fim do período pago.
### Enterprise tem contrato mínimo?
Planos Enterprise podem ter requisitos mínimos dependendo das personalizações necessárias. Entre em contato para discutir sua situação.
## Próximos Passos
Crie sua conta gratuita e explore o Synkrony sem compromisso. Sem cartão de crédito necessário.
Experimente o Standard ou AI Mode por 15 dias com acesso completo.
Selecione o plano ideal para sua equipe e comece a transformar sua gestão de projetos.
Para planos Enterprise ou dúvidas, entre em contato com nossa equipe comercial.
## Suporte e Contato
Precisa de ajuda para escolher o plano ideal?
* **Email**: [suporte@synkrony.com.br](mailto:suporte@synkrony.com.br)
* **Chat**: Disponível na plataforma (Standard, AI Mode e Enterprise)
* **Enterprise**: [enterprise@synkrony.com.br](mailto:enterprise@synkrony.com.br)
Nossa equipe está pronta para ajudar sua Software House a encontrar a solução perfeita!
# Projetos
Source: https://docs.synkrony.ai/projetos
Gerencie seus projetos
# Projetos no Synkrony
Os **Projetos** representam os contratos, iniciativas e repositórios de sua empresa. Cada projeto contém tarefas, épicos e está associado a um cliente.
***
## ➕ Criar um Projeto
Acesse o formulário através do menu lateral em **Novo Projeto**.
### Informações Básicas
| Campo | Descrição |
| --------------- | ----------------------------------------------- |
| **Nome** | Identificação do projeto (ex: "App E-commerce") |
| **Cliente** | Empresa ou pessoa vinculada ao projeto |
| **Repositório** | URL do repositório Github |
| **Cor** | Cor do projeto |
| **Ícone** | Ícone do projeto |
> Também é possível selecionar se o projeto é exclusivo para registro de tempo. Esse tipo de projeto serve só para marcação no TimeTracking.
***
## ❓ FAQ
**Posso arquivar um projeto?** Sim. Projetos arquivados ficam inativos mas mantêm todo o histórico para consulta.
# Integração com Sentry
Source: https://docs.synkrony.ai/sentry-integration
Transforme alertas e issues do Sentry em tarefas acionáveis no Synkrony
# Integração com Sentry
A integração do Synkrony com Sentry conecta **erros, issues e alerts** diretamente ao fluxo de trabalho da sua equipe. Em vez de tratar incidentes de produção fora do planejamento, você transforma cada ocorrência relevante em uma tarefa rastreável dentro do workspace.
Na prática, isso reduz o tempo entre **detecção**, **priorização** e **execução da correção**.
***
## Quando usar essa integração
A integração com Sentry faz mais sentido quando sua equipe já usa o Sentry para monitorar backend, frontend ou jobs assíncronos e quer organizar a resposta dentro do Synkrony.
Casos comuns:
* **Capturar bugs de produção como trabalho real:** um erro crítico vira task automaticamente no projeto correto.
* **Evitar perder alertas importantes:** o problema sai do feed de monitoramento e entra no kanban da equipe.
* **Dar contexto técnico para quem vai corrigir:** stack trace, título do erro e link do Sentry acompanham a task.
* **Fechar o ciclo entre operação e entrega:** quando a correção avança no Synkrony, a issue do Sentry também pode ser resolvida automaticamente.
* **Separar incidentes por cliente, produto ou squad:** cada projeto do Sentry pode criar tarefas no projeto correspondente do Synkrony.
***
## Como funciona
Depois de conectar sua conta do Sentry ao Synkrony, a integração passa a trabalhar em dois sentidos:
### 1. Sentry → Synkrony
Quando uma **issue** ou um **alert** relevante é disparado no Sentry, o Synkrony pode:
* criar uma nova task automaticamente;
* colocar essa task no projeto interno mapeado;
* incluir contexto técnico básico, como título, resumo, link do erro e stack trace;
* exibir o vínculo com o Sentry dentro da task.
### 2. Synkrony → Sentry
Quando a task avança até `Done`, o Synkrony pode:
* marcar a issue correspondente como resolvida no Sentry.
Também é possível fazer o caminho inverso:
* quando uma issue é resolvida no Sentry, a task vinculada pode ser movida automaticamente para `Done`.
***
## O que a integração entrega no dia a dia
### Tarefas criadas automaticamente
Se a automação estiver ativa, novas issues e alerts do Sentry podem gerar tasks sem intervenção manual.
Isso é útil para:
* bugs críticos de produção;
* regressões detectadas logo após deploy;
* alertas de erro recorrente em endpoints, workers ou integrações externas.
### Contexto técnico dentro da task
As tasks criadas a partir do Sentry podem incluir:
* título do erro;
* resumo ou culprit;
* link para abrir a issue/evento no Sentry;
* stack trace quando disponível;
* indicador visual de vínculo com Sentry no card da tarefa.
### Sincronização de resolução
Você pode automatizar o fechamento em ambos os lados:
* **Resolver issue no Sentry ao mover task para Done**
* **Mover task para Done quando a issue for resolvida no Sentry**
Esse fluxo é especialmente útil para equipes que querem manter operação e planejamento alinhados sem atualização manual duplicada.
***
## Fluxos comuns
### Fluxo 1: Erro novo em produção vira tarefa
Exemplo:
1. Um endpoint começa a falhar após um deploy.
2. O Sentry cria uma issue ou dispara um alert.
3. O Synkrony recebe esse evento e cria uma task no projeto certo.
4. A equipe prioriza, corrige e acompanha o trabalho dentro da sprint.
Por que esse fluxo é útil:
* evita que o bug fique só no monitoramento;
* coloca o problema no backlog operacional do time;
* garante rastreabilidade da correção.
### Fluxo 2: Squad de sustentação separa incidentes por projeto
Exemplo:
1. Seu workspace tem projetos por cliente ou produto.
2. Cada projeto do Sentry é vinculado a um projeto interno do Synkrony.
3. Quando chega um alert, a task já nasce no lugar certo.
Por que esse fluxo é útil:
* reduz triagem manual;
* evita criar tarefa no projeto errado;
* facilita priorização por equipe responsável.
### Fluxo 3: Task concluída resolve a issue no Sentry
Exemplo:
1. A equipe corrige o problema e conclui a task.
2. O Synkrony resolve a issue vinculada no Sentry automaticamente.
Por que esse fluxo é útil:
* evita esquecer issue aberta depois da correção;
* mantém métricas do Sentry mais limpas;
* reduz retrabalho operacional.
### Fluxo 4: Issue resolvida no Sentry encerra a task
Exemplo:
1. A issue é resolvida diretamente no Sentry por um fluxo operacional.
2. O webhook atualiza a task no Synkrony e move para `Done`.
Por que esse fluxo é útil:
* bom para times que tratam incidentes primeiro no monitoramento;
* mantém o kanban sincronizado com o estado real do incidente.
***
## Configuração passo a passo
### 1. Acesse as integrações
No Synkrony, vá em:
**Configurações → Integrações → Sentry**
### 2. Conecte sua conta do Sentry
Clique para conectar a integração e concluir a instalação do app do Sentry.
Depois da conexão, o Synkrony passa a reconhecer:
* a instalação do seu workspace no Sentry;
* os projetos disponíveis;
* os webhooks necessários para sincronização.
### 3. Vincule projetos do Sentry aos projetos do Synkrony
Esse é o passo mais importante para a automação funcionar corretamente.
Você deve definir quais projetos externos do Sentry criam tarefas em quais projetos internos do Synkrony.
Exemplo:
* Projeto Sentry `api-backend` → Projeto Synkrony `Backend`
* Projeto Sentry `checkout-web` → Projeto Synkrony `Frontend Checkout`
Sem esse mapeamento, o Synkrony pode receber o evento, mas não saber onde criar a task.
### 4. Ative as automações desejadas
Na tela da integração, você pode configurar:
* **Criar tarefas no workspace**
* **Marcar task como Done quando a issue for resolvida**
* **Resolver issue no Sentry ao mover tasks para Done**
* **Adicionar task à sprint atual**
### 5. Faça um teste controlado
Antes de depender do fluxo em produção, faça um teste com:
* uma issue real do Sentry;
* ou um alert de teste enviado a partir do Sentry.
Depois valide:
* se a task foi criada no projeto esperado;
* se o link com o Sentry apareceu na task;
* se a descrição veio com contexto suficiente;
* se as automações de resolução funcionam como esperado.
***
## Como configurar o alert no Sentry
Para que o Synkrony receba eventos úteis, o caminho mais indicado é configurar um **Issue Alert** no projeto correto dentro do Sentry.
Pela documentação oficial do Sentry, um issue alert dispara quando **um novo evento é recebido** e a regra atende às condições configuradas. Essas regras combinam:
* **triggers:** quando o alert deve disparar;
* **filters:** quais eventos devem ser considerados;
* **actions:** o que o Sentry deve fazer quando a regra for atendida.
Fonte oficial:
* [Create an Issue Alert Rule for a Project](https://docs.sentry.io/api/alerts/create-an-issue-alert-rule-for-a-project/)
* [Alerts & Notifications](https://docs.sentry.io/api/alerts/)
### Configuração recomendada
Se o objetivo é transformar erros relevantes em tasks no Synkrony, comece com uma regra simples e previsível:
* selecione o **projeto** do Sentry que está vinculado ao projeto interno do Synkrony;
* crie um **Issue Alert**;
* use um trigger equivalente a **novo erro / first seen**;
* adicione filtros para reduzir ruído, como ambiente `production`;
* defina frequência para evitar notificações repetidas demais.
### Exemplo de regra inicial
Uma configuração segura para começar:
* **Trigger:** quando uma nova issue é criada;
* **Filtro:** ambiente igual a `production`;
* **Filtro opcional:** apenas eventos com nível `error`;
* **Frequência:** uma vez a cada alguns minutos para a mesma issue.
Esse modelo é bom porque captura problemas novos sem transformar qualquer evento repetido em excesso de trabalho.
### Quando usar alert mais agressivo
Se sua equipe usa o Synkrony como fila operacional de incidentes, você pode criar regras mais fortes, por exemplo:
* issue reapareceu depois de resolvida;
* issue aconteceu mais de `X` vezes em `Y` minutos;
* issue afetou muitos usuários em pouco tempo.
Esse tipo de regra costuma ser melhor para:
* regressões após deploy;
* integrações externas instáveis;
* endpoints críticos de checkout, login ou pagamento.
### Boas práticas de configuração no Sentry
* comece com poucos projetos e poucas regras;
* priorize `production` antes de incluir staging;
* evite regra ampla demais para não criar tasks em excesso;
* revise alertas recorrentes que não geram ação real;
* alinhe cada regra com um projeto já mapeado no Synkrony.
### Como testar a configuração
Depois de criar a regra no Sentry:
1. gere um erro real ou use o envio de teste do alert no próprio Sentry;
2. confirme que o webhook chega ao Synkrony;
3. valide se a task foi criada no projeto esperado;
4. confira se o card da task mostra o vínculo com o Sentry.
Se o evento chegar e a task não for criada, normalmente o problema está em um destes pontos:
* automação de criação de task desativada;
* projeto do Sentry sem vínculo com projeto interno;
* regra do alert configurada para um projeto diferente do mapeado.
***
## Boas práticas
* **Mapeie projetos com cuidado:** isso evita tasks em filas erradas.
* **Ative automação só onde faz sentido:** nem todo alert merece virar task automaticamente.
* **Comece por um projeto piloto:** valide o fluxo antes de expandir para toda a operação.
* **Use o Sentry para detecção e o Synkrony para execução:** essa separação deixa o processo mais claro.
* **Revise regras de alert no Sentry:** alertas muito amplos podem gerar ruído e excesso de tarefas.
***
## Perguntas frequentes
**A integração cria tasks a partir de issues ou de alerts?**
Os dois. Dependendo do tipo de evento recebido pelo app do Sentry, o Synkrony pode aproveitar tanto issues quanto alerts como origem da task.
**Preciso mapear projetos para funcionar?**
Sim. O Synkrony precisa saber em qual projeto interno cada evento do Sentry deve cair.
**A task criada mostra o link para o Sentry?**
Sim. O vínculo com o Sentry aparece na task para facilitar investigação e acompanhamento.
**Posso resolver a issue no Sentry quando concluir a task?**
Sim, desde que a automação correspondente esteja habilitada.
**Posso fazer o contrário e encerrar a task quando a issue for resolvida no Sentry?**
Sim. Esse comportamento também pode ser ativado na configuração da integração.
**Vale a pena para times pequenos?**
Sim, especialmente quando o mesmo time cuida de produto e sustentação. A integração reduz esquecimento e organiza melhor a fila de correções.
***
## Troubleshooting
### O evento chegou do Sentry, mas nenhuma task foi criada
Verifique estes pontos:
* a integração está conectada e ativa;
* a automação de criação de task está habilitada;
* o projeto do Sentry está vinculado a um projeto do Synkrony;
* o evento recebido pertence a um projeto mapeado;
* a issue ou alert recebido contém identificação suficiente para vinculação.
### A task foi criada, mas caiu no projeto errado
Revise o mapeamento entre projeto externo do Sentry e projeto interno do Synkrony.
### A task foi concluída, mas a issue não foi resolvida no Sentry
Confirme se a opção de resolver issue ao mover task para `Done` está habilitada.
### A issue foi resolvida no Sentry, mas a task não foi para `Done`
Confirme se a automação de mover task para `Done` quando a issue é resolvida está habilitada.
***
## Resumo
A integração com Sentry é ideal para equipes que querem tratar incidentes como trabalho estruturado, e não como alerta solto em ferramenta de monitoramento.
Você detecta no Sentry, prioriza no Synkrony e executa a correção no mesmo fluxo usado pelo restante do time.
# Sprints
Source: https://docs.synkrony.ai/sprints
Sistema de ciclos de trabalho do Synkrony
# Sprints no Synkrony
As **Sprints** são ciclos de trabalho projetados para ajudar sua equipe a organizar entregas de forma consistente e previsível. No Synkrony, esse sistema foi desenvolvido especificamente para **Equipes de Software**, unindo flexibilidade e automação para otimizar o fluxo de trabalho.
***
## ⚙️ Configuração de Sprints
As sprints são gerenciadas através do [painel de configurações](https://app.synkrony.ai/settings/sprint).
> **Nota:** Por questões de segurança, estas configurações são restritas aos **administradores** da empresa.
### Duração e Início
* **Duração:** Definida em semanas (1 a 8), servindo de base para todos os ciclos futuros.
* **Dia de Início:** Personalize o dia da semana em que suas sprints começam (padrão: segunda-feira).
> **Ao alterar configurações:** O sistema recalcula automaticamente as datas das sprints futuras. Ao mudar o tipo de nomenclatura, **todas as sprints são renomeadas** (passadas, atual e futuras).
### Nomenclatura
Você pode escolher entre dois formatos de identificação:
1. **Padrão:** `Sprint 1`, `Sprint 2`, `Sprint 3`, etc.
2. **Mensal (Abreviado):** `JAN1`, `FEB2`, `MAR3`, etc.
### Passagem de Sprint (Automação)
Ao final de cada ciclo, o Synkrony processa as tarefas automaticamente. Escolha o modo que melhor se adapta ao seu time:
* **Modo Clássico (Padrão):** Tarefas não finalizadas são movidas para a próxima Sprint com um comentário automático de histórico.
* **Sem Transição:** As tarefas permanecem no estado atual, sem movimentação automática.
***
## 📊 Relatórios e Métricas
Dados precisos são fundamentais para o crescimento do negócio. O Synkrony oferece relatórios detalhados para análise da sprint atual e do histórico da equipe.
### Metas e Pontuação
* **Definição de Metas:** Estabeleça objetivos para os próximos ciclos para calcular a eficiência da equipe.
* **Personalização de Pontos:** Você define quanto cada status do Board vale.
* *Exemplo:* Tarefas em "Concluído" valem **100%** dos pontos, enquanto tarefas em "Code Review" podem valer **50%**.
> Algumas funcionalidades citadas estão em **Beta Fechado**. Se desejar testar esses recursos antecipadamente, entre em contato com nosso suporte.
***
## ❓ FAQ (Perguntas Frequentes)
**Como faço para criar uma Sprint?** Não é necessário criar manualmente. As sprints são geradas automaticamente pelo sistema, que mantém um horizonte de **10 sprints futuras** criadas antecipadamente.
**Posso configurar Sprints diferentes por projeto?** Não. No Synkrony, a configuração é **global (nível empresa)**. Isso garante que todo o time de desenvolvimento esteja coordenado sob o mesmo ritmo, independentemente do projeto em que estejam trabalhando.
# Status do Kanban
Source: https://docs.synkrony.ai/status
Como configurar e personalizar as colunas do seu quadro
# Status do Kanban
Os **Status** representam as colunas visuais do kanban, organizando o fluxo das tarefas desde o planejamento até a entrega. No Synkrony, cada status possui configurações que afetam desde a visualização do board até o cálculo de performance da equipe.
***
## Tipos de Status
Todos os status são agrupados em três categorias principais (status\_type):
| Tipo | Descrição | Uso típico |
| ----------- | ---------------------------------------------------- | ------------------------------------------- |
| **Backlog** | Tarefas planejadas, aguardando priorização ou início | Backlog, Icebox, Arquivo |
| **Ongoing** | Tarefas em algum estágio de desenvolvimento ativo | A Fazer, Em Progresso, Revisão, Code Review |
| **Done** | Tarefas finalizadas e entregues | Concluído, Done, Deployed |
> **Regra:** Cada empresa deve ter pelo menos um status de cada tipo (backlog, ongoing, done).
***
## Status Padrão
Ao criar uma nova empresa, o Synkrony configura automaticamente os seguintes status:
| Nome | Tipo | Pontuação | Cor |
| ----------------------- | ------- | --------- | ------- |
| Backlog | Backlog | - | #8F9FAD |
| A Fazer | Ongoing | 0% | #E5B85C |
| Em Andamento | Ongoing | 25% | #69A0E8 |
| Aguardando Revisão | Ongoing | 50% | #8C85F1 |
| Alterações Requisitadas | Ongoing | 75% | #8C85F1 |
| Done | Done | 100% | #33D391 |
> **Nota:** Esta configuração é **global (nível empresa)**. Todos os projetos compartilham os mesmos status.
***
## Personalizando Status
### O que você pode configurar
Através de **Configurações → GitHub**, os administradores podem:
* **Adicionar novos status:** Criar etapas intermediárias ou específicas para seu processo
* **Renomear status existentes:** Usar a terminologia do seu time
* **Alterar cores:** Personalizar a identidade visual do kanban
* **Definir pontuação:** Configurar quanto cada status vale no cálculo de performance
* **Mapeamento GitHub:** Configurar qual status corresponde a cada evento de PR
### Reordenando Status
A ordem dos status define a sequência visual das colunas no kanban. Arraste os status na tela de configuração para reorganizá-los conforme seu fluxo de trabalho.
### Pontuação (Average Score)
A pontuação de cada status (0-100%) é usada para calcular a **eficiência** nos relatórios de performance:
* **0%:** Tarefas que ainda não começaram
* **25-75%:** Tarefas em progresso (quanto maior, mais próxima da conclusão)
* **100%:** Tarefas concluídas
> **Regra:** Pelo menos um status do tipo "done" deve ter pontuação 100%.
***
## Mapeamento com GitHub
Cada status pode ter um **GitHub Status Type** que define como eventos de Pull Request afetam automaticamente a tarefa:
| GitHub Status Type | Descrição |
| ------------------- | ------------------------------------------------- |
| `none` | Status sem mapeamento específico com GitHub |
| `review` | PR aberto e aguardando revisão |
| `changes_requested` | PR precisa de alterações solicitadas pelo revisor |
| `done` | PR foi mergeado (tarefa concluída) |
| `approved` | PR foi aprovado pelo revisor |
| `others` | Interações gerais/comentários |
### Mapeamento Padrão
| Status | GitHub Status Type |
| ----------------------- | ------------------- |
| Backlog | `none` |
| A Fazer | `none` |
| Em Andamento | `none` |
| Aguardando Revisão | `review` |
| Alterações Requisitadas | `changes_requested` |
| Done | `done` |
> **Regra:** Apenas um status por empresa pode ter cada tipo de mapeamento GitHub.
***
## Fluxos de Trabalho Comuns
### Fluxo Simples
```
Backlog → A Fazer → Em Andamento → Done
```
Ideal para times pequenos ou projetos simples.
### Fluxo com Revisão
```
Backlog → A Fazer → Em Andamento → Aguardando Revisão → Done
```
Adiciona uma etapa de revisão antes da conclusão.
### Fluxo com Code Review Detalhado
```
Backlog → A Fazer → Em Andamento → Aguardando Revisão → Aprovado → Done
↓ (se necessário)
Alterações Requisitadas
```
Fluxo completo com aprovação explícita e ciclo de ajustes.
### Fluxo com Deploy
```
Backlog → A Fazer → Em Andamento → Code Review → Aprovado → QA → Deploy → Done
```
Inclui etapas de QA e deploy antes da conclusão final.
***
## Boas Práticas
### 1. Mantenha Simples
Comece com poucos status e adicione conforme necessário. Muitas colunas podem dificultar a visualização.
### 2. Alinhe com o Processo
Os status devem espelhar como o time realmente trabalha, não o contrário.
***
## ❓ FAQ
**Posso ter diferentes status por projeto?**
Não. Os status são configurados em nível de empresa, garantindo consistência em todos os projetos.
**O que acontece se eu excluir um status que está em uso?**
As tarefas naquele status serão movidas para outro status do mesmo tipo (backlog/ongoing/done).
**Por que não posso ter dois status com o mesmo github\_status\_type?**
Para garantir clareza na automação. Quando um PR é aprovado, o sistema precisa saber exatamente para qual status mover a tarefa.
**A pontuação afeta algo além dos relatórios de performance?**
Não. A pontuação é usada apenas nos cálculos de eficiência dos relatórios de sprint.
**Posso alterar a ordem dos status depois de criados?**
Sim! Basta arrastar os status na tela de configuração. A alteração é imediata e afeta apenas a visualização.
# Tarefas
Source: https://docs.synkrony.ai/tarefas
Gerencie e acompanhe tarefas individuais
# Tarefas no Synkrony
As **Tarefas** são a unidade fundamental de trabalho no Synkrony. Cada tarefa representa algo a ser implementado, corrigido ou documentado.
***
## ➕ Criar uma Tarefa
Use o atalho **`N`** em qualquer lugar do sistema ou clique em **+ Nova Tarefa** no menu do projeto.
### Campos Essenciais
| Campo | Descrição |
| ---------------- | ------------------------------ |
| **Título** | Nome curto e descritivo |
| **Descrição** | Detalhes, aceitação e contexto |
| **Status** | Coluna atual no kanban |
| **Épico/Modulo** | Agrupamento (opcional) |
| **Estimativa** | Pontos ou horas |
| **Assignee** | Responsável pela tarefa |
***
## 📦 Épicos e Módulos
**Épicos** (ou Módulos) são agrupadores de tarefas que representam grandes entregas ou funcionalidades do projeto. Eles ajudam a organizar o trabalho em blocos coerentes e rastreáveis.
### Criar um Épico
Dentro de qualquer projeto, acesse a criação de tarefa. No selecionador de **Épico**, é possível criar um novo Épico diretamente.
### Vincular Tarefas ao Épico
Ao criar ou editar uma tarefa, selecione o **Épico** correspondente. A tarefa será agrupada sob aquele épico automaticamente, permitindo visualização consolidada do progresso.
***
## 🔗 Integração GitHub
Vincule cada tarefa a uma **issue ou PR do GitHub**:
1. Cole a URL da issue/PR no campo correspondente
2. O status da tarefa sincroniza automaticamente com o PR
3. Commits e comentários aparecem no histórico da tarefa
> **Nota:** Requer configuração prévia da [Integração GitHub](/github-integration).
***
## ⏱️ Time Tracking
Registre tempo diretamente na tarefa:
* **Timer embutido:** Inicie/pare sem sair da página
* **Manual:** Adicione entradas de tempo passadas
O tempo é somado por tarefa, por épico e por projeto.
***
## 🏷️ Etiquetas e Prioridade
* **Labels:** Categorize por tipo, prioridade, time, etc.
* **Prioridade:** Visual (baixa, média, alta, crítica)
***
## ❓ FAQ
**Como movo tarefas entre projetos?** Edite a tarefa e altere o campo "Projeto". O histórico é mantido.
**Posso duplicar uma tarefa?** Sim, use a opção "Duplicar" no menu de ações da tarefa.
# Rastreamento de Tempo
Source: https://docs.synkrony.ai/time-tracking
Controle preciso das horas trabalhadas pela equipe
O **Rastreamento de Tempo** do Synkrony permite registrar e acompanhar as horas trabalhadas pela equipe em cada tarefa, fornecendo dados essenciais para análise de produtividade, precificação de projetos e cálculo de custos.
Acesse o rastreamento de tempo através do menu lateral: **Relatórios → Time Tracking**.
***
## 💡 Por Que Registrar Tempo
Registrar o tempo trabalhado vai muito além de controle — é uma ferramenta estratégica para Software Houses modernas. Entenda os principais benefícios:
### 1. Ponto de Trabalho para Equipes Remotas
Em times distribuídos, o time tracking serve como **ponto de presença digital**, substituindo a visibilidade física do escritório:
* **Sinal de disponibilidade:** Um timer ativo indica que o colega está trabalhando naquele momento
* **Transparência de atividades:** Gestores e colegas veem em que tarefas cada pessoa está focada
* **Respeito ao foco:** Saber que alguém está com o timer ativo em uma tarefa complexa reduz interrupções desnecessárias
* **Sensação de pertencimento:** Ver a equipe trabalhando simultaneamente cria conexão, mesmo à distância
**Na prática:** Ao verificar o kanban, você vê não apenas o status das tarefas, mas também quem está ativamente trabalhando em cada uma. Isso facilita colaboração e evita que duas pessoas trabalhem no mesmo item sem saber.
***
### 2. Disponibilidade em Tempo Real
O timer ativo é um indicador instantâneo de quem está **disponível para reuniões** e colaboração:
* **Evite interrupções:** Antes de chamar alguém para uma reunião, verifique se o timer está ativo — se estiver, avalie se pode esperar
* **Identifique momentos livres:** Usuários sem timer ativo provavelmente estão em pausa, disponíveis para conversar
* **Planeje reuniões melhor:** Agende encontros em períodos onde há maior disponibilidade da equipe
* **Respeite o flow:** Estado de fluxo (deep work) é valioso — interromper alguém com timer ativo pode custar caro em produtividade
**Na prática:** "Vi que você está com o timer ativo na tarefa de integração de pagamento — posso te chamar em 30 minutos quando terminar?" é muito mais respeitoso do que interromper o trabalho.
***
### 3. Melhorar Estimativas Futuras
Dados históricos de tempo são a base para **estimativas mais precisas**:
* **Compare estimado vs real:** Aprenda quais tipos de tarefas costumam levar mais tempo que o planejado
* **Identifique padrões:** Descubra que "integração com API externa" historicamente leva 2x mais tempo que o estimado
* **Ajuste fatores de risco:** Com dados passados, adicione buffers adequados para tarefas arriscadas
* **Benchmark por desenvolvedor:** Entenda a velocidade de cada membro e atribua tarefas adequadamente
**Na prática:** Após 3 sprints com time tracking, você percebe que tarefas categorizadas como "complexidade alta" levam em média 8 horas, mas foram estimadas em 6. Na próxima sprint, estime em 8-10 horas.
***
### 4. Estimar Custos em Equipes Flexíveis
Para Software Houses com **múltiplos projetos simultâneos**, o time tracking é essencial para precificação correta:
* **Custeio por projeto:** Saiba exatamente quanto tempo (e dinheiro) cada projeto consome da equipe
* **Identifique projetos deficitários:** Descubra projetos que custam mais em horas do que o contrato vale
* **Negocie reajustes:** Com dados concretos, negocie aumentos de escopo ou valores com clientes
* **Balanceamento de equipe:** Redistribua desenvolvedores se um projeto está consumindo desproporcionalmente mais tempo
* **Precificação de novos projetos:** Use dados históricos para precificar projetos similares com maior confiança
**Na prática:** Um projeto contratado por R$ 50.000 está consumindo 400 horas de desenvolvedor sênior (custo/hora R$ 150). Isso é R$ 60.000 em custos apenas com essa senioridade — o projeto está prejuízo R$ 10.000. Com time tracking, você descobre isso a tempo de corrigir.
***
## ⏱️ Como Funciona
O sistema de time tracking oferece flexibilidade para diferentes formas de trabalho:
* **Timer em tempo real:** Inicie e pare o timer enquanto trabalha
* **Registro manual:** Adicione tempo trabalhado posteriormente
* **Múltiplas tarefas:** Registre tempo em diferentes tarefas ao longo do dia
* **Edição de registros:** Ajuste registros quando necessário
### Dados Calculados
O sistema calcula automaticamente:
* **Tempo total:** Soma de todas as horas registradas
* **Tempo por tarefa:** Horas trabalhadas em cada item
* **Tempo por projeto:** Consolidado por projeto
* **Tempo por sprint:** Horas trabalhadas no período
* **Tempo por usuário:** Individual por membro da equipe
***
## 📝 Registrando Tempo
### Via Timer (Tempo Real)
1. Abra a tarefa que deseja trabalhar
2. Clique no botão **Iniciar Timer**
3. O timer começará a contar no topo da interface
4. Quando terminar, clique em **Parar Timer**
5. O tempo será registrado automaticamente
> O timer permanece ativo mesmo se você navegar para outras páginas. Não esqueça de parar ao finalizar o trabalho!
### Via Registro Manual
1. Abra a tarefa
2. Clique em **Adicionar Time Log**
3. Preencha as informações:
* **Data:** Selecione o dia em que trabalhou
* **Horas:** Quantidade de horas trabalhadas
* **Descrição:** (opcional) O que foi feito
4. Clique em **Salvar**
### Editando um Registro
1. Na tarefa, encontre o time log na lista
2. Clique no botão de edição
3. Ajuste as informações necessárias
4. Salve as alterações
***
## 📊 Relatórios de Tempo
Acesse relatórios detalhados através do menu **Relatórios → Time Tracking**.
### Filtros Disponíveis
* **Por período:** Selecione um intervalo de datas específico
* **Por projeto:** Filtre por um ou mais projetos
* **Por usuário:** Veja o tempo de membros específicos da equipe
* **Por sprint:** Analise o tempo por ciclo de trabalho
* **Por tarefa:** Detalhe horas em tarefas específicas
### Visualizações
* **Lista detalhada:** Todos os registros com informações completas
* **Agrupado por usuário:** Tempo total por pessoa
* **Agrupado por projeto:** Consolidado por cliente/projeto
* **Agrupado por data:** Distribuição ao longo do tempo
***
## 💾 Exportando Dados
### Exportação PDF
Gere relatórios em PDF para compartilhar com clientes ou para arquivamento:
1. Aplique os filtros desejados
2. Clique em **Exportar PDF**
3. O arquivo será gerado com todos os dados filtrados
> A exportação PDF está disponível nos planos Standard, AI Mode e Enterprise
### O que está incluído no PDF
* Período analisado
* Lista de todos os time logs
* Total de horas por usuário
* Total de horas por projeto
* Resumo geral do período
***
## 💰 Diferenças Entre Planos
O acesso às funcionalidades de Time Tracking varia conforme o plano:
### Plano Free
* **Registro pessoal:** Cada usuário pode registrar自己的 tempo
* **Visualização individual:** Apenas seus próprios registros
* **Sem exportação PDF:** Não gera relatórios em PDF
* **Sem relatório de equipe:** Não acessa os dados de outros membros
### Planos Standard, AI Mode e Enterprise
* **Relatório de equipe:** Visualize tempo de todos os membros
* **Exportação PDF:** Gere relatórios para compartilhar
* **Filtros avançados:** Filtre por projeto, usuário, período, sprint
* **Agrupamentos:** Múltiplas formas de visualizar os dados
* **Integração financeira:** Dados usados no Relatório Financeiro
***
## 🎯 Boas Práticas
1. **Registre diariamente:** Não acumule tempo para registrar depois
2. **Use descrições:** Adicione notas sobre o que foi feito em cada período
3. **Seja preciso:** Registre o tempo real, não aproximado
4. **Pare o timer:** Sempare o timer ao fazer pausas ou mudar de contexto
5. **Revise semanalmente:** Verifique se não esqueceu de registrar algum tempo
6. **Use para estimativas:** Compare tempo estimado vs tempo real para melhorar futuras estimativas
***
## 🔗 Integração com Outros Recursos
O Time Tracking se integra com outras funcionalidades do Synkrony:
### Relatório Financeiro
As horas registradas são usadas para calcular custos da equipe:
* **Custo da equipe:** Horas trabalhadas × custo/hora de cada usuário
* **Margem de contribuição:** Receita menos custos (incluindo custo de equipe)
* Configure o custo/hora em **Configurações → Equipe**
### Relatório de Performance
Análise de produtividade da equipe através das sprints:
* **Horas por sprint:** Tempo total trabalhado em cada ciclo
* **Evolução:** Compare produtividade entre sprints
* **Por usuário:** Identifique membros mais ou menos produtivos
### GitHub Integration
Tempo registrado em tarefas conectadas ao GitHub:
* **Sincronização:** Tarefas vinculadas a PRs registram contexto
* **Visibilidade:** Veja quanto tempo foi gasto em cada PR
***
## ❓ FAQ
**O time tracking é obrigatório?**
Não. O registro de tempo é opcional, mas altamente recomendado para Software Houses que precisam calcular custos e precificar projetos.
**Posso editar time logs de outros usuários?**
Apenas administradores e proprietários podem editar registros de outros membros da equipe.
**O que acontece se eu esquecer de parar o timer?**
O timer continuará contando indefinidamente. Você pode editar o registro posteriormente para ajustar o tempo correto.
**Posso registrar tempo em tarefas concluídas?**
Sim. Você pode adicionar time logs em qualquer tarefa, independentemente do status.
**Os dados de tempo são visíveis para clientes?**
Não. O time tracking é interno e visível apenas para membros da sua empresa.
**Como funciona o custo/hora no cálculo financeiro?**
Configure o custo/hora de cada usuário em **Configurações → Equipe**. O Relatório Financeiro multiplica as horas trabalhadas por esse valor para calcular custos da equipe.
***
## 📚 Documentação Relacionada
* [Relatório Financeiro](/financial-report) - Use as horas para calcular custos e margens
* [Relatório de Performance](/performance-report) - Analise a produtividade da equipe
* [Sprints](/sprints) - Organize ciclos de trabalho para análise temporal