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:
Install Gammacode
Mac & Linux:curl -fsSL https://gammacode.dev/install | bash
Invoke-WebRequest -Uri https://gammacode.dev/install.ps1 -OutFile install.ps1; .\install.ps1
Verify installation
This checks that Gammacode is properly installed and shows the version. Authenticate if needed
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:
Initialize Gammacode context
> analyze this project structure and suggest a development workflow
Set up project-specific configuration
/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.
Navigate to the project root directory
Ask for a high-level overview
> give me an overview of this codebase
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.
Ask Gammacode to find relevant files
> find the files that handle user authentication
Get context on how components interact
> how do these authentication files work together?
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.
Share the error with Gammacode
> I'm seeing an error when I run npm test
Ask for fix recommendations
> suggest a few ways to fix the @ts-ignore in user.ts
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.
Identify legacy code for refactoring
> find deprecated API usage in our codebase
Get refactoring recommendations
> suggest how to refactor utils.js to use modern JavaScript features
Apply the changes safely
> refactor utils.js to use ES2024 features while maintaining the same behavior
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.
Identify untested code
> find functions in NotificationsService.swift that are not covered by tests
Generate test scaffolding
> add tests for the notification service
Add meaningful test cases
> add test cases for edge conditions in the notification service
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.
Summarize your changes
> summarize the changes I've made to the authentication module
Generate a PR with Gammacode
Review and refine
> enhance the PR description with more context about the security improvements
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.
Identify undocumented code
> find functions without proper JSDoc comments in the auth module
Generate documentation
> add JSDoc comments to the undocumented functions in auth.js
Review and enhance
> improve the generated documentation with more context and examples
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.
Add an image to the conversation
You can use any of these methods:
- Drag and drop an image into the Gammacode window
- Copy an image and paste it into the CLI with ctrl+v (Do not use cmd+v)
- Provide an image path to Gammacode. E.g., “Analyze this image: /path/to/your/image.png”
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?
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?
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.
Reference a single file
> Explain the logic in @src/utils/auth.js
Reference a directory
> What's the structure of @src/components?
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.
Create a custom agent
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
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
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
