Skip to main content
Learn how to set up and optimize your development environment for maximum productivity with Gammacode.

​
Setting up your environment

​
Install Gammacode

Get Gammacode installed and ready for development:
1

Install Gammacode

Mac & Linux:
curl -fsSL https://gammacode.dev/install | bash
Windows PowerShell:
Invoke-WebRequest -Uri https://gammacode.dev/install.ps1 -OutFile install.ps1; .\install.ps1
2

Verify installation

gammacode --version
This checks that Gammacode is properly installed and shows the version.
3

Authenticate if needed

gammacode login
Follow the browser authentication flow to connect your account.

​
Development environment integration

​
IDE setup and extensions

Optimize your editor for the best Gammacode experience: VS Code recommendations:
  • Install language-specific extensions for syntax highlighting
  • Configure auto-save for seamless Gammacode file monitoring
  • Set up integrated terminal for easy Gammacode access
Terminal setup: 
# Add Gammacode to your shell profile for easy access
echo 'alias gc="gammacode"' >> ~/.bashrc  # or ~/.zshrc
source ~/.bashrc  # or ~/.zshrc

​
Project initialization workflow

Set up new projects with Gammacode:
1

Navigate to your project

cd /path/to/your/project
2

Initialize Gammacode context

gammacode

> analyze this project structure and suggest a development workflow
3

Set up project-specific configuration

> /init
/init analyzes your codebase and creates a project-specific AGENTS.md file containing build commands, code style guidelines, and project conventions that Gammacode will follow throughout your development workflow.

​
Common workflows

Learn about common workflows with Gammacode.
Each task in this document includes clear instructions, example commands, and best practices to help you get the most from Gammacode.

​
Understand new codebases

​
Get a quick codebase overview

Suppose you’ve just joined a new project and need to understand its structure quickly.
1

Navigate to the project root directory

cd /path/to/project
2

Start Gammacode

gammacode
3

Ask for a high-level overview

> give me an overview of this codebase
4

Dive deeper into specific components

> explain the main architecture patterns used here

> what are the key data models?

> how is authentication handled?
Tips:
  • Start with broad questions, then narrow down to specific areas
  • Ask about coding conventions and patterns used in the project
  • Request explanations of project-specific terminology

​
Find relevant code

Suppose you need to locate code related to a specific feature or functionality.
1

Ask Gammacode to find relevant files

> find the files that handle user authentication
2

Get context on how components interact

> how do these authentication files work together?
3

Understand the execution flow

> trace the login process from front-end to database
Tips:
  • Be specific about what you’re looking for
  • Use domain language from the project

​
Fix bugs efficiently

Suppose you’ve encountered an error message and need to find and fix its source.
1

Share the error with Gammacode

> I'm seeing an error when I run npm test
2

Ask for fix recommendations

> suggest a few ways to fix the @ts-ignore in user.ts
3

Apply the fix

> update user.ts to add the null check you suggested
Tips:
  • Tell Gammacode the command to reproduce the issue and get a stack trace
  • Mention any steps to reproduce the error
  • Let Gammacode know if the error is intermittent or consistent

​
Refactor code

Suppose you need to update old code to use modern patterns and practices.
1

Identify legacy code for refactoring

> find deprecated API usage in our codebase
2

Get refactoring recommendations

> suggest how to refactor utils.js to use modern JavaScript features
3

Apply the changes safely

> refactor utils.js to use ES2024 features while maintaining the same behavior
4

Verify the refactoring

> run tests for the refactored code
Tips:
  • Ask Gammacode to explain the benefits of the modern approach
  • Request that changes maintain backward compatibility when needed
  • Do refactoring in small, testable increments

​
Work with tests

Suppose you need to add tests for uncovered code.
1

Identify untested code

> find functions in NotificationsService.swift that are not covered by tests
2

Generate test scaffolding

> add tests for the notification service
3

Add meaningful test cases

> add test cases for edge conditions in the notification service
4

Run and verify tests

> run the new tests and fix any failures
Tips:
  • Ask for tests that cover edge cases and error conditions
  • Request both unit and integration tests when appropriate
  • Have Gammacode explain the testing strategy

​
Create pull requests

Suppose you need to create a well-documented pull request for your changes.
1

Summarize your changes

> summarize the changes I've made to the authentication module
2

Generate a PR with Gammacode

> create a pr
3

Review and refine

> enhance the PR description with more context about the security improvements
4

Add testing details

> add information about how these changes were tested
Tips:
  • Ask Gammacode directly to make a PR for you
  • Review Gammacode’s generated PR before submitting
  • Ask Gammacode to highlight potential risks or considerations

​
Handle documentation

Suppose you need to add or update documentation for your code.
1

Identify undocumented code

> find functions without proper JSDoc comments in the auth module
2

Generate documentation

> add JSDoc comments to the undocumented functions in auth.js
3

Review and enhance

> improve the generated documentation with more context and examples
4

Verify documentation

> check if the documentation follows our project standards
Tips:
  • Specify the documentation style you want (JSDoc, docstrings, etc.)
  • Ask for examples in the documentation
  • Request documentation for public APIs, interfaces, and complex logic

​
Work with images

Suppose you need to work with images in your codebase, and you want Gammacode’s help analyzing image content.
1

Add an image to the conversation

You can use any of these methods:
  1. Drag and drop an image into the Gammacode window
  2. Copy an image and paste it into the CLI with ctrl+v (Do not use cmd+v)
  3. Provide an image path to Gammacode. E.g., “Analyze this image: /path/to/your/image.png”
2

Ask Gammacode to analyze the image

> What does this image show?

> Describe the UI elements in this screenshot

> Are there any problematic elements in this diagram?
3

Use images for context

> Here's a screenshot of the error. What's causing it?

> This is our current database schema. How should we modify it for the new feature?
4

Get code suggestions from visual content

> Generate CSS to match this design mockup

> What HTML structure would recreate this component?
Tips:
  • Use images when text descriptions would be unclear or cumbersome
  • Include screenshots of errors, UI designs, or diagrams for better context
  • You can work with multiple images in a conversation
  • Image analysis works with diagrams, screenshots, mockups, and more

​
Reference files and directories

Use @ to quickly include files or directories without waiting for Gammacode to read them.
1

Reference a single file

> Explain the logic in @src/utils/auth.js
This includes the full content of the file in the conversation.
2

Reference a directory

> What's the structure of @src/components?
This provides a directory listing with file information.
Tips:
  • File paths can be relative or absolute
  • @ file references add AGENTS.md in the file’s directory and parent directories to context
  • Directory references show file listings, not contents
  • You can reference multiple files in a single message (e.g., “@file1.js and @file2.js”)

​
Use specialized agents

Suppose you want to use specialized AI agents to handle specific tasks more effectively.
1

Create a custom agent

gammacode agent create
This opens an interactive flow where you can:
  • Choose location (Current project or Global)
  • Enter a description (e.g., “security analysis”)
  • Select which tools the agent can access
  • The agent is created as .gammacode/agent/agent_name.md
2

Use agents automatically

Gammacode will automatically delegate appropriate tasks to specialized agents:
> review my recent code changes for security issues

> run all tests and fix any failures
3

Explicitly request specific agents

> use the code-reviewer agent to check the auth module

> have the debugger agent investigate why users can't log in
Tips:
  • Create project-specific agents in .gammacode/agent/ for team sharing
  • Use descriptive descriptions to enable automatic delegation
  • Limit tool access to what each agent actually needs
  • Agents help maintain focused expertise for specialized tasks

​
Ask Gammacode about its capabilities

Gammacode has built-in access to its documentation and can answer questions about its own features and limitations.

​
Example questions

> can Gammacode create pull requests?

> how does Gammacode handle permissions?

> what slash commands are available?

> what are the limitations of Gammacode?
Gammacode provides documentation-based answers to these questions. For executable examples and hands-on demonstrations, refer to the specific workflow sections above.
Tips:
  • Gammacode always has access to the latest documentation, regardless of the version you’re using
  • Ask specific questions to get detailed answers
  • Gammacode can explain complex features and advanced workflows

​
Next steps

Developer Workflows

Explore advanced development patterns and workflows

CLI Reference

Complete command reference and options

Configuration

Customize Gammacode for your workflow

Troubleshooting

Solutions for common development issues
⌘I