# Developer Platform
Welcome to your team’s developer platform
What Is Guilde?
Guilde helps AI generate the most reliable production-ready code. By redesigning each step in the SDLC, Guilde prevents the most common reasons agents waste your time. Automatically inherit the latest tactics, tools, and models so you spend less time refreshing Reddit and more time shipping features.
### What can Guilde do?
* **Generate & update documentation:** Prevent stale documentation from undermining the quality of AI generated code by continuously updating documentation.
* **Identify & eliminate technical debt:** Detect and resolve code quality issues, maintenance burdens, and refactoring opportunities so your team remains focused on the highest impact work.
* **Reduce review burden:** Guilde ensures the integrity of tests, linters, and rules to prevent wasted time and effort during PR reveiws.
### How to maximize team's attention
Guilde pairs with developers to help refine their requirements, standardize design patterns and security best practices. That way developers don't need to babysit progress as AI agents develop their plan, to do's or coding. When code is complete, Guilde conducts rigorous unit and end-to-end tests to detect and remediate failures without wasting the team's time. When PRs are ready for review, your team can be confident that all low hanging fruit has already been addressed.
{% columns %}
{% column %}
### Enterprise Grade Security
To enforce enterprise grade security and compliance, Guilde deploys entirely in the customer's cloud and leverages customer supplied LLM API keys.
Get started
{% endcolumn %}
{% column %}
{% code title="ind" overflow="wrap" %}
```go
./guilde init
```
{% endcode %}
{% endcolumn %}
{% endcolumns %}
# Welcome
Guilde helps AI generate the most reliable production-ready code. By redesigning each step in the SDLC, Guilde prevents the most common reasons agents waste your time. Automatically inherit the latest tactics, tools, and models so you spend less time refreshing Reddit and more time shipping features.
### Jump right in
# Customer Hosted Guilde Installation
Follow these steps in order to install Guilde in your cloud.
### Assets Provided By Guilde Support Staff
* URL to access the Guilde installer
* Credentials to access the Guilde AWS ECS Image Registry
### Requirements
* Workstation: The current version of the Guilde installer is an Apple Silicon MacOS binary. More platforms will be available soon.
* Recommended browser: Chrome
Before using the Guilde installer, validate that the \~/.aws folder has the necessary permissions to access the AWS account in which Guilde will be installed. Best practice is to use a new AWS sub-account.
The Guilde CLI expects \~/.aws/config to have a default region defined:
```
~/.aws/config
[default]
region = us-west-1
```
The Guilde CLI expects the \~/.aws/credentials to have same the aws\_access\_key\_id and aws\_secret\_access\_key as the AWS account in which Guilde will be installed.
```
~/.aws/credentials
[default]
aws_access_key_id =
aws_secret_access_key =
```
Note: To locate the access\_key\_id and secret\_access\_key in the AWS console, click on Username in the top right of the screen. Select security credentials and scroll down to Access keys.
### Step 1: Guilde Init
Run:
```
./guilde init
```
Guilde init writes to \~/.guilde/deployments/production
### Step 2: Guilde Installer
The Guilde Installer will ask several questions to complete your installation. When prompted, answer as directed below:
* Where will Guilde be hosted: Define the URL on which you intend to host Guilde (e.g. [guilde.dev.COMPANY.com](http://guilde.dev.front.com/))
* Deployment Size: Small
* Enter the AWS ECS Keys provided by your Guilde representative. These are provided to give your cluster access to our images.
* AWS Access Key ID: Provided by Guilde team
* AWS Secret Access Key: Provided by Guilde team
* Generate Encryption Key: Yes
* AWS Region: Choose the region you prefer (e.g. us-west-1)
* EKS Cluster: Choose the “new cluster” option
* SSL Certificate: Choose to generate new ACM certificate (Amazon Certificate Manager)
* \* Note that you may see a warning “Could not retrieve validation record: no validation records found” - this is fine.
* Kubernetes Namespace: guilde
* Install AWS Load Balancer Controller: Yes
* Enable AWS Verified Access with Cognito: Yes
* Access Policy Name: guilde-access-policy
* Do you have an existing Cognito User Pool: No, create one
* Allowed Email Domains: include any domains employees have email addresses for - do not include public email services such as gmail.com. Any user with an email address that matches these filters will be permitted to create an account on the Guilde system.
* Initialize: Yes
* Create EKS Cluster: Yes
* Certificate Validation Required: Add the provided CNAME record to DNS to prove ownership of the domain name to Amazon Certificate Manager:
Type: CNAME
Name: XXXXXXX
Value: XXXXXXX
Optional: Navigate to AWS Certificate Manager in the AWS Account on which Guilde will be installed. Select “Certificates” and then the Certificate for the subdomain selected at the beginning of guilde init. Wait for that certificate to move from “Pending Validation” to “Issued.”
### Step 3: Deployment
Run:
```
./guilde status --deployment production
```
Run:
```
./guilde deploy --deployment production
```
On success, DNS CONFIGURATION REQUIRED will appear
Set up this last CNAME in your DNS.
### Step 3: Install Guilde Application
* To install the Guilde GitHub application, enter the GitHub Organization Name and select “Preview”
* Review the GitHub App Configuration and select “Create GitHub App”
* GitHub App Name will appear. Select “Create GitHub App.”
* Define an Organization Name. Note that this does not need to be the same as the GitHub Organization name. Select “Create Organization.”
* Select “Open in GitHub”
* Select the repositories you intend Guilde to work in, then select “Install.”
* Select the option to “Continue with GitHub” at the bottom of the Sign In page.
* Select “Authorize Guilde”
* Select Sign Up button at the bottom of the Sign In page
* Enter email address and define a password. Select “Create Account.”
* Select “Link GitHub Account”
* Upon success, the message “GitHub account linked successfully” will appear:
### Step 4: Configure LLM API Keys
* Copy and paste the OpenAI and Anthropic API keys that were already provisioned into the Guilde Application
* Select “Save Changes”
### Step 5: Initiate Your First Sprint
* In the Guilde application, navigate to the Dashboard page and select “New Sprint.”
* Name the sprint “documentation-001” and assign it the same working branch name: documentation-001. Be sure to choose a branch name that does not yet exist in the repository.
* Select the repository
* The base branch will be automatically generated
* Select the “Documentation-workflow”
* Select Create.
* Once workflow complete, please review the generated documentation on the branch "documentation-001"
* After the Sprint completes, review the documentation Guilde generates.
* Review the code quality issues identified in the Technical Debt Analysis and consider creating Sprints to mitigate each issue.
# Guilde Installation
Follow these steps in order to install Guilde.
### Step 1: Register for Firewall
* Visit the URL provided by your Account Administrator to begin the Sign Up process for your firewall.
* Select “Sign Up” option to create an AWS Verified Access account in order to securely access the Guilde application.
* Enter your company email address & define a password then click "Sign Up." Only email addresses from your corporate domain will be valid.
* Retrieve Account Verification Code by navigating to your email provider. Look for an email from “verificationemail.com”
### Step 2: Install Guilde GitHub Application
* To install the Guilde GitHub application, enter the GitHub Organization Name and select “Preview”
* Review the GitHub App Configuration and select “Create GitHub App”
* GitHub App Name will appear. Select “Create GitHub App.”
* Name your Organization. Note that this does not need to be the same as the GitHub Organization name. Select “Create Organization.”
* Select “Open in GitHub”
* Select the repositories you intend Guilde to work in, then select “Install.”
* Select “Authorize Guilde”
### Step 3: Register for Guilde
* Now that you can access your account behind the firewall, you will create your Guilde user account. Select Sign Up button at the bottom of the Sign In page
* Enter email address and define a password. Select “Create Account.”
* Select “Link GitHub Account”
* Upon success, the message “GitHub account linked successfully” will appear:
### Step 4: Configure LLM API Keys
* Copy and paste the OpenAI and Anthropic API keys that were already provisioned into the Guilde Application
* Select “Save Changes”
### Step 5: Restart Service
* Before you can initiate your first sprint, you MUST restart the service. We apologize for the inconvenience.
* Navigate to the Settings Tab and scroll down to the bottom of the page. Click "Restart Services"
### Step 6: Initiate Your First Sprint
* In the Guilde application, navigate to the Dashboard page and select “New Sprint.”
* Select the repository
* Paste in an existing spec or type in a rough idea of what you'd like to build.
* Select Create.
* Once the sprint completes, it's status will appear as "Done and Pushed" in the Dashboard. You can navigate to GitHub to review the branch.
# User Onboarding
Guilde helps AI generate the most reliable production-ready code. By redesigning each step in the SDLC, Guilde prevents the most common reasons agents waste your time. Automatically inherit the latest
### Sign Up For An Account
* Visit the URL provided by your Account Administrator to begin the Sign Up process for your firewall.
* AWS Verified Access Sign Up Process: Select “Sign Up” option to create an AWS Verified Access account in order to securely access the Guilde application.
* Create an Email and Password and select “Sign Up”
* Retrieve Account Verification Code by navigating to your email provider. Look for an email from “verificationemail.com”
* Verify Account by copying and pasting the confirmation code into the Guilde UI. Select “Confirm Account.”
* Guilde Application Sign Up Process: Select Sign Up button at the bottom of the Sign In page
* Enter email address and define a password. Select “Create Account.”
* Select “Link GitHub Account”
* Authorize Guilde: Select “Authorize Guilde”
### Initiate Your First Sprint
* In the Guilde application, navigate to the Dashboard page and select “New Sprint.”
* Name the sprint “documentation-001” and assign it the same working branch name: documentation-001. Be sure to choose a branch name that does not yet exist in the repository.
* Select the repository
* The base branch will be automatically generated
* Select the “Documentation-workflow”
* Select Create.
* Once workflow complete, please review the generated documentation on the branch "documentation-001"
* After the Sprint completes, review the documentation Guilde generates.
* Review the code quality issues identified in the Technical Debt Analysis and consider creating Sprints to mitigate each issue.
# Concepts
A summary of the core concepts used by Guilde
| Concept | Definition |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sprint | A markdown file (ex: `documentation.md`) that defines what you intend to build. |
| Workflow | The instructions and agent assignments to build a sprint. |
| Documentation | The analysis Guilde performs to understand the codebase structure, security, performance, code consistency, architecture, cyclomatic complexity and technical debt for any repository Guilde will generate code in. |
### Workflow
A WORKFLOW orchestrates several CODING AGENTS, as directed by the WORKFLOW STEPS and the AGENT definitions.
Each WORKFLOW STEP is afforded its own CODING AGENT and CONTEXT WINDOW. WORKFLOW STEPs collaborate in a defined fashion to build software. The prompts in WORKFLOW STEPs instruct the CODING AGENT.
Note that the same CODING AGENT can be used for 1 or more WORKFLOW STEPs.
Users can customize WORKFLOWs and AGENTs by modifying files in their repositories.
WORKFLOWS can be found at: `/.guilde/workflows/`
AGENTS can be found at: `/.opencode/agent/`
### Adding Workflow Templates
* Guilde includes a library of Workflow Templates to help you get started and improve the quality of the code Guilde authors. To adopt these templates, you will need to:
* Download this file: :
* Unzip the file
* From the customer-template, copy the .guilde and .opencode folders into the root of your git repository.
* Recreate the structure of docs/sprints/sprint-0001/sprint-0001.md in your repository or copy in the docs directory from the customer-template.
* Push those changes and merge them into your default branch. Wait 5 minutes for those assets to be accessible to Guilde.
# Example Sprint
How Guilde's sprint documents are formatted
Sprints are markdown documents that define the requirements of software you intend to build. They serve as inputs to Guilde Workflows that refine, execute, and test the software.
A sprint includes:
* Overview
* Context
* Requirements
* Approach
For example:
```
install go
## Overview
Implement a centralized YAML-based configuration system to manage all git-forensics-demo settings, flags, and options.
This system will serve as the foundation for all configurable parameters across the application.
## Context
Currently, git-forensics-demo relies on command-line flags for configuration.
This approach limits flexibility and makes it difficult to maintain consistent settings across runs.
A YAML-based configuration system will provide a centralized, persistent, and flexible way to manage all application settings.
## Requirements
- YAML configuration file with sensible defaults at `~/.git-forensics-demo/config.yml`
- Support for environment variable override via `$CONFIG_FILE`
- Command-line flag `--config ` to specify custom config location
- All existing CLI flags should be configurable via YAML
- Configuration precedence: Config file > Defaults
- the CLI should no longer take in any positional arguments other than the repository name that we are analyzing
- Validate configuration on load with clear error messages
- the only flag argument that can be provided is the config file path --config
## Approach
use TDD. Ensure that the requirements are covered by tests. If there are existing tests that have a similar scope
for old behavior, they should be modified. For a given incremental feature we should make the test, then make implement
i.e,. test1, impl1, test2, impl2, ..., test_n, impl_n
```
# Help Center
