The AI Code Review Agent supports two deployment options:

• Bito Cloud (fully managed)

• Self-hosted service (run on your own infrastructure)

Each option comes with its own set of benefits and considerations.

This guide walks you through both options to help you determine which deployment model best fits your team’s needs.

Bito Cloud

Bito Cloud provides a managed environment for running the AI Code Review Agent, offering a seamless, hassle-free experience. This option is ideal for teams looking for quick deployment and minimal operational overhead.

Pros:

• Simplicity: Enjoy a straightforward setup with a single-click installation process, making it easy to get started without technical hurdles.

• Maintenance-Free: Bito Cloud takes care of all necessary updates and maintenance, ensuring your Agent always operates on the latest software version without any effort on your part.

• Scalability: The platform is designed to easily scale, accommodating project growth effortlessly and ensuring reliable performance under varying loads.

Cons:

• Handling of Pull Request Diffs: For analysis purposes, diffs from pull requests are temporarily stored on our servers.

Install/run using Bito Cloud

Self-hosted service

Self-hosted AI Code Review Agent offers a higher degree of control and customization, suited for organizations with specific requirements or those who prefer to manage their own infrastructure.

Pros:

• Full Control: Self-hosting provides complete control over the deployment environment, allowing for extensive customization and the ability to integrate with existing systems as needed.

• Privacy and Security: Keeping the AI Code Review Agent within your own infrastructure can enhance data security and privacy, as all information remains under your direct control.

Cons:

• Setup Complexity: Establishing a self-hosted environment requires technical know-how and can be more complex than using a managed service, potentially leading to longer setup times.

• Maintenance Responsibility: The responsibility of maintaining and updating the software falls entirely on your team, which includes ensuring the system is scaled appropriately to handle demand.

Install/run as a self-hosted service

Bito is an AI-powered code review tool that helps you catch bugs, security vulnerabilities, code smells, and other issues in your pull requests. By understanding your entire codebase, Bito provides context-aware, actionable suggestions to improve both code quality and security.

It includes real-time recommendations from dev tools you already use such as static code analysis, open source vulnerability scanners, linters, and secrets scanning tools (e.g., passwords, API keys, sensitive information, etc.).

Bito seamlessly integrates with GitHub, GitLab, and Bitbucket.

Start free trialGetting started guide

See AI Code Review Agent in action

Quickstart guide

Helpful resources

Feature guides

Video library

Need help?

If you have any questions, feel free to email us at [email protected]

Bito automatically saves the chat session History. The session history is stored locally on your computer. You can return to any chat session and continue the AI conversation from where you left off. Bito will automatically maintain and restore the memory of the loaded chat session.

You can "Delete" any saved chat session or share a permalink to the session with your coworkers.

Here is the video overview of accessing and managing the session history.

Any Shortcut such as "Performance Check" or "Improve Readability" that proposes changes to your existing code automatically opens a "Diff View" between the proposed and actual code. This allows you to review the changes before accepting them into your code. The diff view opens automatically when Bito AI returns the proposed changes. You can also view the diff at any point through the "Diff" action.

Video showing side-by-side diff view

Save time and effort by quickly creating a new instance using the configuration settings of an existing one. It’s a fast and simple way to set up multiple Agent instances without having to reconfigure each one.

Follow the steps below to get started:

1. and select a workspace to get started.

2. From the left sidebar, select .

1. If your Bito workspace is connected to your GitHub/GitLab/Bitbucket account, a list of AI Code Review Agent instances configured in your workspace will appear. Locate the instance you wish to duplicate and click the Clone button given in front of it.

1. An Agent configuration form will open, pre-populated with the input field values. You can edit these values as needed.

1. Click Select repositories to choose Git repositories for the new Agent.

1. To enable code review for a specific repository, simply select its corresponding checkbox. You can also enable repositories later, after the Agent has been created. Once done, click Save and continue to save the new Agent configuration.

1. When you save the configuration, your new Agent instance will be added and available on the page.

The self-hosted AI Code Review Agent offers a more private and customizable option for teams looking to enhance their code review processes within their own infrastructure, while maintaining complete control over their data. This approach is ideal for organizations with specific compliance, security, or customization requirements.

Understanding CLI vs webhooks service

When setting up the AI Code Review Agent, you have the flexibility to choose between two primary modes of operation: CLI and webhooks service.

• CLI allows developers to manually initiate code reviews directly from terminal. This mode is ideal for quick, on-demand code reviews without the need for continuous monitoring or integration.

• Webhooks service transforms the Agent into a persistent service that automatically triggers code reviews based on specific events, such as pull requests or comments on pull requests. This mode is suitable for teams looking to automate their code review processes.

For more details, visit the page.

Deployment Options

Based on your needs and the desired integration level with your development workflow, choose one of the following options to install and run the AI Code Review Agent:

1. : Ideal for developers seeking a simple, interactive way to conduct code reviews from the command line.

2. : Perfect for teams looking to automate code reviews through external events, enhancing their CI/CD workflow.

3. : A great option for GitHub users to seamlessly integrate automated code reviews into their GitHub Actions workflows.

Enabling unicode For Windows 10 and below

Unicode characters (using other languages) might not be readily supported on command prompt if you are on Windows 10 or below. You can run command chcp 936 in cmd prior to using bito to support unicode characters in Windows 10 or below.

Using Homebrew for Bito CLI

1. Before using homebrew, please make sure that you uninstall any previously installed versions of Bito CLI using the .

2. Once above is done then you can use following commands to install Bito CLI using homebrew:

   1. First tap the CLI repo using brew tap gitbito/bitocli command, this should be a one time action and not required every time.

   2. Now you can install Bito CLI using following command:

      • brew install bito-cli - this should install Bito CLI based upon your machine architecture.

   3. To update Bito CLI to the latest version, use following commands:

      1. Please make sure you always do brew update before upgrading to avoid any errors.

      2. brew update - this will update all the required packages before upgrading.

      3. brew upgrade bito-cli - once above is done, this will update Bito CLI to the latest version.

   4. To uninstall Bito CLI you can either use the or use following commands:

      • brew uninstall bito-cli - this should uninstall Bito CLI completely from your system.

Bito Cloud lets you integrate the AI Code Review Agent into your CI/CD pipeline for automated code reviews. This document provides a step-by-step guide to help you configure and run the script successfully.

Installation and Configuration Steps

1. Select the appropriate Git provider guide from this link based on your Git provider, and follow the step-by-step instructions to install the AI Code Review Agent using Bito Cloud. Be sure to review the prerequisites and the installation/configuration steps provided in the documentation.

2. Download the bito-action-script folder from GitHub, which includes a shell script (bito-actions.sh) and a configuration file (bito_action.properties).

3. You can integrate the AI Code Review Agent into your CI/CD pipeline in two ways, depending on your preference:

• Option 1: Using the bito_action.properties File

  • Configure the following properties in the bito_action.properties file located in the downloaded bito-action-script folder.

• Run the following command:

  • ./bito_actions.sh bito_action.properties

  • Note: When using the properties file, make sure to provide all the three parameters in .properties file

• Option 2: Using Runtime Values

  • Provide all necessary values directly on the command line:

    • ./bito_actions.sh agent_instance_url=<agent_instance_url> agent_instance_secret=<secret> pr_url=<pr_url>

    • Replace <agent_instance_url>, <secret>, and <pr_url> with your specific values.

  • Note: You can also override the values given in the .properties file or provide values that are not included in the file. For example, you can configure agent_instance_url and agent_instance_secret in the bito_action.properties file, and only pass pr_url on the command line during runtime.

    • ./bito_actions.sh bito_action.properties pr_url=<pr_url>

    • Replace <pr_url> with your specific values.

1. Incorporate the AI Code Review Agent into your CI/CD pipeline by adding the appropriate commands to your build or deployment scripts. This integration will automatically trigger code reviews as part of the pipeline, enhancing your development workflow by enforcing code quality checks with every change.

You can try asking any question you may have in mind regarding your codebase. In most cases, Bito will give you an accurate answer. Bito uses AI to determine if you are asking about something in your codebase.

However, if you want to ask a question about your code no matter what, then you can use our pre-defined keywords such as "my code", "my repo", "my project", "my workspace", etc., in your question.

The complete list of these keywords is given on our Available Keywords page.

Here are some popular use cases (with example questions):

Code Explanation

• What a particular code file does

  • In my code what does code in sendgrid/sendemail.sh do?

• What a particular function in my code does

  • In my repo explain what function message_tokens do

Code Translation

• In my project rewrite the code of signup.php file in nodejs

Code Refactoring

• In my workspace suggest code refactoring for api.py and mention all other files that need to be updated accordingly

Fix Bugs

• In my code find runtime error possibilities in script.js

• Find logical errors in scraper.py in my code

Detect Code Smells

• In my code detect code smells in /app/cart.php and give solution

Generate Documentation

• Generate documentation for search.ts in my workspace in markdown format

Generate Unit tests

• In my code write unit tests for index.php

• In my code generate test code for code coverage of cache.c

Summarize Recent Code Changes

• summarize recent code changes in my code

Code Search using natural language

• Any function to compute tokens in my project?

• Any code or script to send emails in my workspace?

• In my repo list all the line numbers where $alexa array is used in index.php.

Give details of making modifications

• In my code list all the files and code changes needed to add column desc in table raw_data in dailyReport DB.

Bito deploys a Vector Database locally on the user’s machine, bundled as part of the Bito IDE plug-in. This database uses Embeddings (a vector with over 1,000 dimensions) to retrieve text, function names, objects, etc. from the codebase and then transform them into multi-dimensional vector space.

Then when you give it a function name or ask it a question, that query is converted into a vector and is compared to other vectors nearby. This returns the relevant search results. So, it's a way to perform search not on keywords, but on meaning. Vector Databases are able to do this kind of search very quickly.

Bito also uses an Agent Selection Framework that acts like an autonomous entity capable of perceiving its environment, making decisions, and taking actions to achieve certain goals. It figures out if it’s necessary to do an embeddings comparison on your codebase, do we need to perform an action against Jira, or do we do something else.

Finally, Bito utilizes Large Language Models (LLMs) from Open AI, Anthropic, and others that actually provide the answer to the question by leveraging the context provided by the Agent Selection Framework and the embeddings.

This is what makes us stand out from other AI tools like ChatGPT, GitHub Copilot, etc. that do not understand your entire codebase.

We’re making significant innovations in our AI Stack to simplify coding for everyone. To learn more about this head over to Bito’s AI Stack documentation.

bito config [flags]

• run bito config -l or bito config --list to list all config variables and values.

• run bito config -e or bito config --edit to open the config file in default editor.

Sample Configuration

bito:
 access_key: ""
 email: [email protected]
 
 preferred_ai_model: ADVANCED
settings:
 auto_update: true
 max_context_entries: 20

What is an Access Key and How to Get it?

Access Key is an alternate authentication mechanism to Email & OTP based authentication. You can use an Access Key in Bito CLI to access various functionalities such as Bito AI Chat. Here’s a guide on how to create an Access Key. Basically, after creating the Access Key, you have to use it in the config file mentioned above. For example, access_key: “YOUR_ACCESS_KEY_HERE”

Access Key can be persisted in Bito CLI by adding it in the config file using bito config -e. Such persisted Access Key can be over-ridden by running bito -k <access-key> or bito --key <access-key> for the transient session (sessions that last only for a short time).

Preferred AI Model Type

By default AI Model Type is set to ADVANCED and it can be overridden by running bito -m <BASIC/ADVANCED>. Model type is used for AI query in the current session. Model type can be set to BASIC or ADVANCED, which is case insensitive.

"ADVANCED" refers to AI models like GPT-4o, Claude Sonnet 3.5, and best in class AI models, while "BASIC" refers to AI models like GPT-4o mini and similar models.

When using Basic AI models, your prompts and the chat's memory are limited to 40,000 characters (about 18 single-spaced pages). However, with Advanced AI models, your prompts and the chat memory can go up to 240,000 characters (about 110 single-spaced pages). This means that Advanced models can process your entire code files, leading to more accurate answers.

If you are seeking the best results for complex tasks, then choose Advanced AI models.

To see how many Advanced AI requests you have left, please visit the Requests Usage page. On this page, you can also set hard and soft limits to control usage of Advanced AI model requests for your workspace and avoid unexpected expenses.

Also note that even if you have set preferred_ai_model: ADVANCED in Bito CLI config but your Advanced AI model requests quota is finished (or your self-imposed hard limit is reached) then Bito CLI will start using Basic AI models instead of Advanced AI models.

We do not offer any student discounts or different pricing for nonprofits or educational institutions. We are exploring this for the future.

To ensure that you are not billed for the upcoming month, kindly cancel your subscription before the 1st day of the upcoming month.

On your machine or in a Private Cloud, you can run the AI Code Review Agent via either CLI or webhooks service. This guide will teach you about the key differences between CLI and webhooks service and when to use each mode.

Difference Between CLI and webhooks service

The main difference between CLI and webhooks service lies in their operational approach and purpose. In CLI, the docker container is used for a one-time code review. This mode is ideal for isolated, single-instance analyses where a quick, direct review of the code is needed.

On the other hand, webhooks service is designed for continuous operation. When set in webhooks service mode, the AI Code Review Agent remains online and active at a specified URL. This continuous operation allows it to respond automatically whenever a pull request is opened in a repository. In this scenario, the git provider notifies the server, triggering the AI Code Review Agent to analyze the pull request and post its review as a comment directly on it.

When to Use CLI and When to Use webhooks service

Selecting the appropriate mode for code review with the AI Code Review Agent depends largely on the nature and frequency of your code review needs.

CLI: Ideal for Specific, One-Time Reviews

CLI mode is best suited for scenarios requiring immediate, one-time code reviews. It's particularly effective for:

• Conducting quick assessments of specific pull requests.

• Performing periodic, scheduled code analyses.

• Reviewing code in environments with limited or no continuous integration support.

• Integrating with batch processing scripts for ad-hoc analysis.

• Using in educational settings to demonstrate code review practices.

• Experimenting with different code review configurations.

• Reviewing code on local setups or for personal projects.

• Performing a final check before pushing code to a repository.

CLI mode stands out for its simplicity and is perfect for standalone tasks where a single, direct execution of the code review process is all that's needed.

Webhooks service: For Continuous, Automated Reviews

Webhooks service, on the other hand, is the go-to choice for continuous code review processes. It excels in:

• Continuously monitoring all pull requests in a repository.

• Providing instant feedback in collaborative projects.

• Seamlessly integrating with CI/CD pipelines for automated reviews.

• Performing automated code quality checks in team environments.

• Conducting real-time security scans on new pull requests.

• Ensuring adherence to coding standards in every pull request.

• Streamlining the code review process in large-scale projects.

• Maintaining consistency in code review across multiple projects.

• Enhancing workflows in remote or distributed development teams.

• Offering prompt feedback in agile development settings.

Webhooks service is indispensable in active development environments where consistent monitoring and immediate feedback are critical. It automates the code review process, integrating seamlessly into the workflow and eliminating the need for manual initiation of code reviews.

Parameters are the individual elements of a Large Language Model that are learned from the training data. Think of them as the synapses in a human brain—tiny connections that store learned information.

How Parameters Work in LLMs

Each parameter in an LLM holds a tiny piece of information about the language patterns the model has seen during training. They are the fundamental elements that determine the behavior of the model when it generates text.

For example, imagine teaching a child what a cat is by showing them pictures of different cats. Each picture tweaks the child's understanding and definition of a cat. In LLMs, each training example tweaks the parameters to better understand and generate language.

The Role of Parameters in Understanding and Generating Language

Parameters are crucial because they allow the model to perform tasks such as translation, write articles, and even generate source code. When you ask an AI a question, the parameters work together to sift through the learned patterns and generate a response that makes sense based on the training it received.

For instance, if you ask an AI to write a poem, the parameters will determine how to structure the poem, what words to use, and how to create rhyme or rhythm, all based on the data it was trained on.

The Scale of LLM Parameters: Just How Large Are We Talking?

When we say "Large" in LLM, we're not kidding. The size of a language model is directly related to the number of parameters it has.

Take GPT-4, for example, with its 1.76 trillion parameters. That's like 1.76 trillion different dials the model can tweak to get language just right. Each parameter holds a piece of information that can contribute to understanding a sentence's structure, the meaning of a word, or even the tone of a text.

Earlier models had significantly fewer parameters. GPT-1, for instance, had only 117 million parameters. With each new generation, the number of parameters has grown exponentially, leading to more sophisticated and nuanced language generation.

Training LLMs: How Parameters Learn

Training an LLM involves a process called "backpropagation" where the model makes predictions, checks how far off it is, and adjusts the parameters accordingly.

Let's say we're training an LLM to recognize the sentiment of a sentence. We show it the sentence "I love sunny days!" tagged as positive sentiment. The LLM predicts positive but isn't very confident. During backpropagation, it adjusts the parameters to increase the confidence for future similar sentences.

This process is repeated millions of times with millions of examples, gradually fine-tuning the parameters so that the model's predictions become more accurate over time.

Parameter’s Impact on AI Performance and Limitations

The number of parameters is one of the key factors influencing an AI model's performance. However, more parameters can mean a model requires more computational power and data to train effectively, which can lead to increased costs and longer training times.

With great power comes great responsibility—and greater chances of making mistakes. More parameters can sometimes mean that the model starts seeing patterns where there aren't any, a phenomenon known as "overfitting" where the model performs well on training data but poorly on new, unseen data.

The Future of Parameters in LLMs

The future of LLMs might not just be about adding more parameters, but also about making better use of them. Innovations in how parameters are structured and how they learn are ongoing.

AI researchers are exploring ways to make LLMs more parameter-efficient, meaning they can achieve the same or better performance with fewer parameters. Techniques like "parameter sharing" and "sparse activation" are part of this cutting-edge research.

Conclusion

Parameters in LLMs are the core elements that allow these models to understand and generate human-like text. While the sheer number of parameters can be overwhelming, it's their intricate training and fine-tuning that empower AI to interact with us in increasingly complex ways.

As AI continues to evolve, the focus is shifting from simply ramping up parameters to refining how they're used, ensuring that the future of AI is not just smarter but also more efficient and accessible.

A prompt, in the simplest terms, is the initial input or instruction given to an AI model to elicit a response or generate content. It's the human touchpoint for machine intelligence, a cue that sets the AI's gears in motion.

Prompts are more than mere commands; they are the seeds from which vast trees of potential conversations and content grow. Think of them as the opening line of a story, the question in a quiz, or the problem statement in a mathematical conundrum – the prompt is the genesis of the AI's creative or analytical output.

For example, when you ask GPT-4o "What's the best way to learn a new language?" you've given it a prompt. The AI then processes this and generates advice based on its training data.

The Art of Prompt Engineering

Prompt engineering is a discipline in itself, evolving as an art and science within AI communities. Crafting effective prompts is akin to programming without code; it's about phrasing and framing your request to the AI in a way that maximizes the quality and precision of its output.

Good prompt engineering can involve:

• Being specific: Clearly defining what you want the AI to do.

• Setting the tone: Informing the AI of the style or mood of the content you expect.

• Contextualizing: Providing background information to guide the AI's responses.

Example: Instead of saying, "Tell me about France," a well-engineered prompt would be, "Write a short travel guide for first-time visitors to France, highlighting top attractions, cultural etiquette, and local cuisine."

The Role of Prompts in Generative AI

Generative AI, which includes everything from text to image generation models, relies heavily on prompts to determine the direction of content creation. Prompts for generative AI act as a blueprint from which the model can conjure up entirely new pieces of content – whether that's an article, a poem, a piece of art, or a musical composition.

Prompts tell the AI not just what to create, but can also suggest how to create it, influencing creativity, tone, structure, and detail. As generative AI grows more sophisticated, the potential for complex and nuanced prompts increases, allowing for more customized and high-fidelity outputs.

Example: Prompting an AI with "Create a poem in the style of Edgar Allan Poe about the sea" instructs the model to adopt a specific literary voice and thematic focus.

Challenges and Considerations

Crafting the perfect prompt isn't always straightforward. One of the challenges lies in the AI's interpretation of the prompt. Ambiguity can lead to unexpected or unwanted results, while overly restrictive prompts may stifle the AI's creative capabilities.

Moreover, ethical considerations arise when prompts are designed to elicit biased or harmful content. The AI's response is contingent upon its training data, and if that data includes prejudiced or false information, the output may reflect those biases. Responsible prompt engineering thus also involves an awareness of potential harm and the implementation of safeguards against it.

Example: To avoid bias in AI-generated news summaries, prompts should be engineered to require neutrality and fact-checking.

Conclusion

Prompts are the simple commands or questions we use to kickstart a conversation with AI, guiding it to understand and generate the responses or content we seek. They're like the steering wheel for the AI's capabilities, crucial for navigating the vast landscape of information and creativity the AI models offer.

As we continue to interact with and shape AI technology, mastering the use of prompts becomes our way of ensuring that the conversation flows in the right direction. Simply put, the better we become at asking, the better AI gets at answering.

So, the next time you interact with a language model, remember that the quality of the output is often a direct reflection of your input - your prompt is the key.

Bito Cloud offers a single-click solution for using the AI Code Review Agent, eliminating the need for any downloads on your machine. You can create multiple instances of the Agent, allowing each to be used with a different repository on a Git provider such as GitHub, GitLab, or Bitbucket.

We also support GitHub (Self-Managed), GitLab (Self-Managed), and Bitbucket (Self-Managed).

Connect Bito to your Git provider

Select your Git provider from the options below and follow the step-by-step installation guide to seamlessly set up your AI Code Review Agent.

Ask questions directly to the AI Code Review Agent regarding its code review feedback. You can inquire about highlighted issues, request alternative solutions, or seek clarifications on suggested fixes.

Real-time collaboration with the AI Code Review Agent accelerates your development cycle. By delivering immediate, actionable insights, it eliminates the delays typically experienced with human reviews. Developers can engage directly with the Agent to clarify recommendations on the spot, ensuring that any issues are addressed swiftly and accurately.

Bito supports over 20 languages—including English, Hindi, Chinese, and Spanish—so you can interact with the AI in the language you’re most comfortable with.

How to chat?

To start a conversation, type your question directly as a reply to the Agent’s code review comment.

The AI Code Review Agent will analyze your comment and determine if it’s a valid and relevant question.

• If the agent decides it’s a valid question, it will respond with helpful insights.

• If the agent determines it’s unclear, off-topic, or not related to its feedback, it will not respond.

To help the agent recognize your question faster, you can also tag your comment with @bitoagent or @askbito. Tagging informs the Agent that your message is intended as a question. However, tagging does not guarantee a reply. The agent will still analyze your comment and decide whether it is a valid question worth responding to.

Bito usually responds within about 10 seconds.

• On GitHub and Bitbucket, you may need to manually refresh the page to see the response.

• On GitLab, updates happen automatically.

What you can ask about

When chatting with the AI Code Review Agent, you can ask questions to better understand or improve the code feedback it provided. Here are examples of what you can ask:

• Clarifications about a highlighted issue Ask the AI to explain why it flagged a certain line of code or why something might cause a problem.

• Request for alternative solutions Request different ways to fix or improve the code beyond what was originally suggested.

• Deeper explanations If you want to understand the technical reasoning behind a suggestion (e.g., security concerns, performance impacts, best practices), you can ask for more detailed explanations.

• Request for examples Ask the AI to provide an example snippet showing the corrected or improved code.

• Trade-off discussions Ask the AI about pros and cons of different approaches it may have suggested (e.g., performance vs. readability).

• Best practices guidance Request advice on best practices related to the specific code snippet — such as naming conventions, error handling, optimization tips, or design patterns.

• Language-specific advice If you’re working in a particular language (e.g., JavaScript, Python, Java), you can ask for language-specific guidance related to the comment.

• Request for more context If the suggestion feels too "short" or "surface level," you can ask the AI to explain more about the broader coding or architectural concept behind its feedback.

• Security and safety questions If a suggestion touches on security (like input validation, authentication, or encryption), you can ask for further security-related advice.

• Testing and validation Ask the AI if it recommends writing any tests based on its code suggestions and what those tests might look like.

What you cannot ask about

The AI can only answer questions related to its own code review comments.

• You cannot ask general questions about the repository or unrelated topics.

• You cannot start a new thread independently — your question must be a reply to a comment made by Bito’s AI Code Review Agent.

If your comment is not linked to a Bito review comment, the AI will not respond.

Bito delivers context-aware AI code reviews directly in your favorite editors — VS Code, Cursor, Windsurf, and all JetBrains IDEs. It detects bugs, code smells, security vulnerabilities, performance bottlenecks, and other production-critical issues with minimal noise, while providing clear, high-quality suggestions to fix them.

With developers increasingly relying on AI tools to generate code at unprecedented speed — a practice often called “vibe coding” — the volume of code requiring review has exploded. While AI can help write code faster, it can also introduce subtle bugs and inconsistencies that traditional manual reviews might miss. This makes intelligent, automated code review not just helpful, but essential for maintaining code quality in an AI-accelerated development environment.

Bito's AI helps developers dramatically accelerate their impact. It's a Swiss Army knife of capabilities that can 10x your developer productivity and save you an hour a day, using the same models as ChatGPT!

What can you do with Bito?

Bito AI is a general-purpose AI assistance in that developers can ask any technical question, generate code from the natural language prompts, and get feedback on the existing code. Here are some things you can do with Bito AI Knowledge Assistance.

1. Generate Code: Ask Bito to generate code in any language with the natural language prompt. (e.g., write a Java function to convert a number from one base to another)

2. Command Syntax: Ask for the syntax of any technical command. (e.g., How to set a global variable for git?")

3. Test Cases: Generate test cases for the code.

4. Explain Code: Explain the selected code. Ask how this code works or what it does.

5. Comment Method: Generate a comment for the function or method to add to your code.

6. Improve Performance: Ask how you can improve the performance of a given code.

7. Check Security: Ask if the selected code has any known security issues.

8. Learn Technical Concepts: Ask a question about any technical concept (e.g., Explains B+ trees, explain Banker's algorithm)

Through extensions, Bito meets you where you work, your IDEs, like Visual Studio Code or JetBrains family of IDE.

Next, learn how to install Bito extensions.

Get up and running with Bito in just a few steps! Bito seamlessly integrates with popular JetBrains IDEs such as IntelliJ IDEA, PyCharm, and WebStorm, providing powerful AI-driven code reviews directly within your editor. Click the button below to quickly install the Bito extension and start optimizing your development workflow with context-aware AI Chat, and more.

Video guide

Watch the video below to learn how to download the Bito extension on JetBrains IDEs.

Step-by-step instructions

1. In JetBrains IDEs such as IntelliJ, go to File -> Settings to open the Settings dialog, and click Plugins -> Marketplace tab in the settings dialog. Search for Bito.

2. Click "Install" to install the Bito extension. We recommend you restart the IDE after the installation is complete.

3. Bito panel will appear on the right-hand sidebar. Click it to complete the setup process. You will either need to create a new workspace if you are the first in your company to install Bito or join an existing workspace created by a co-worker. See Managing workspace members

The IDE customization settings are accessible through the new toolbar dropdown menu titled "Extension Settings".

Light and Dark Themes

In Visual Studio Code and JetBrains IDEs, you can choose between a light or dark theme for the Bito panel to match your coding environment preference. For VS Code users, Bito also offers an adaptive theme mode in which the Bito panel and font colors automatically adjust based on your selected VS Code theme, creating a seamless visual experience.

You can set the desired theme through the Theme dropdown.

Theme Screenshots

“Always Light” Theme

“Always Dark” Theme

“Light” or “Dark” Theme - Matching IDE

“Adaptive” Theme

Theme adapted from “Noctis Lux”:

Theme adapted from “Solarized Light”:

Theme adapted from “Tomorrow Night Blue”:

Theme adapted from “barn-cat”:

Font Size Control

Take control of your code readability! Within the Bito extension settings, you can now adjust the font size for a comfortable viewing experience.

You can set the desired font size through the Font Size text field. However, if you check the Font Size (Match with IDE Font) checkbox, it will override the set font size with the Editor font size.

Bito has created the ability for our AI to understand your codebase, which produces dramatically better results that are personalized to you. This can help you write code, refactor code, explain code, debug, and generate test cases – all with the benefits of AI knowing your entire code base.

Bito AI automatically figures out if you're asking about something in your code. If it's confident, it grabs the relevant parts of your code from our index and feeds them to the Large Language Models (LLMs) for accurate answers. But if it's unsure, Bito will ask you to confirm before proceeding.

For now, this feature is only available for our Team Plan which costs $15 per user per month. We have plans to release it for our Free Plan soon. But it will be limited to repos of 10MB indexable size.

Recent breakthroughs in Generative AI and Large Language Models (LLMs) have helped make many AI Coding Assistant tools available, including Bito, to help you develop software faster.

The major issue with these AI assistants, though, is that they have no idea about your entire codebase. Some tools take context from currently opened files in your IDE, while others enable you to manually enter code snippets in a chat-like interface and then ask questions about them.

But with Bito’s AI that understands your entire repository, this is a whole new capability. For example, what if you could ask questions like:

• how can I add a button to mute and unmute the song to my code in my music player? By default, set this button to unmute. Also, use the same design as existing buttons in UI.

• In my code list all the files and code changes needed to add column desc in table raw_data in dailyReport DB.

• In my code suggest code refactoring for api.py and mention all other files that needs to be updated accordingly

• Please write the frontend and backend code to take a user’s credentials, and authenticate the user. Use the authentication service in my code

This will definitely improve the way you build software.

Bito Access Key allows for an alternate authentication mechanism in contrast to the standard Email & OTP based authentication. Access Keys can be created via the Bito Web UI and utilized within the Bito CLI. This guide outlines the process of creating or deleting an Access Key.

Creating an Access Key

Follow these steps to create a Bito Access Key:

1. Log in to your account at: https://alpha.bito.ai/

2. Navigate to Settings > Advanced settings by visiting this link.

3. Click the Create new key button.

4. Enter a name for your Bito Access Key to make it easily identifiable.

5. Click Create Bito Access Key to generate your key.

6. Copy the key immediately, as it will not be displayed again after you close the popup.

Deleting an Access Key

To delete an existing Bito Access Key, follow these steps:

1. Log in to your account at: https://alpha.bito.ai/

2. Navigate to Settings > Advanced settings by visiting this link.

3. Click the trash icon next to the Bito Access Key you want to delete.

4. A confirmation popup will appear asking if you are sure you want to delete the key. Click Yes to proceed.

Bito maintains your billing history through Stripe.

To view your past payments, follow these steps:

1. Open the Manage Subscription > Billing and Plans page.

2. Click on the "View billing history" button. You will be redirected to a secure page powered by Stripe.
3. On this page, you will see your complete billing history.
4. Open a specific invoice to view its complete details.
5. From the invoice page, you can view more details by clicking “View invoice and payment details”.
6. You can also download the invoice and the receipt from this page by clicking the “Download invoice” and “Download receipt” buttons respectively.

E-mail

Please write to us at [email protected] for any issue you might face with Bito. We would love to hear feedback, comments, feature requests, and how Bito improves your development experience.

Engage with Community

Engage with our constantly growing Slack community.

Bito Github

Bito Github is growing. Engage with your fellow developers at https://github.com/gitbito

If you no longer need an instance, you can delete it to keep your workspace organized. Follow the steps below to quickly remove any unused Agents.

1. and select a workspace to get started.

2. From the left sidebar, select .

   If your Bito workspace is connected to your GitHub/GitLab/Bitbucket account, a list of AI Code Review Agent instances configured in your workspace will appear.

1. Before deleting an Agent, ensure that any repositories currently using it are reassigned to another Agent otherwise a warning popup will appear.

1. Locate the Agent you wish to delete and click the Delete button given in front of it.

How do I whitelist Bito's gateway IP address for my on-premise Git platform?

To ensure the operates smoothly with your GitHub (Self-Managed) or GitLab (Self-Managed), please whitelist all of Bito's gateway IP addresses in your firewall to allow incoming traffic from Bito. This will enable Bito to access your self-hosted repository.

List of IP addresses to whitelist:

• 18.188.201.104

• 3.23.173.30

• 18.216.64.170

The agent response can come from any of these IPs.

How can I prevent the AI Code Review Agent from stopping due to token expiry?

You should set a longer expiration period for your GitHub Personal Access Token (Classic) or GitLab Personal Access Token. We recommend setting the expiration to at least one year. This prevents the token from expiring early and avoids disruptions in the AI Code Review Agent's functionality.

Additionally, we highly recommend updating the token before expiry to maintain seamless integration and code review processes.

For more details on how to create tokens, follow these guides:

• GitHub Personal Access Token (Classic):

• GitLab Personal Access Token:

What is "Estimated effort to review" in code review output?

This is an estimate, on a scale of 1-5 (inclusive), of the time and effort required to review this Pull Request (PR) by an experienced and knowledgeable developer. A score of 1 means a short and easy review, while a score of 5 means a long and hard review. It takes into account the size, complexity, quality, and the needed changes of the PR code diff. The score is produced by AI.

Why does Bito need access to my Git account?

Bito requires certain permissions to analyze pull requests and provide AI-powered code reviews. It never stores your code and only accesses the necessary data to deliver review insights.

What permissions does Bito need?

Bito requires:

1. Read access to code and metadata: To analyze PRs and suggest improvements

2. Read and write access to issues and pull requests: To post AI-generated review comments

3. Read access to organization members: To provide better review context

I don’t have admin permissions. Can I still use Bito?

If you don’t have admin access, you’ll need your administrator to install Bito on your organization’s Git account. Once installed, you can use it for PR reviews on allowed repositories. GitHub also sends a notification to the organization owner to request the organization owner to install the app.

Does Bito store my code?

No, Bito does not store or train models on your code. It only analyzes pull request data in real-time and provides suggestions directly within the PR.

Can I choose which repositories Bito has access to?

Yes, after installation, you can select specific repositories instead of granting access to all. You can also manage repository access later through our web dashboard.

What happens after I install the Bito App?

Once installed, you’ll be redirected to Bito, where you can:

1. Select repositories for AI-powered reviews

2. Customize review settings to fit your workflow

3. Open a pull request to start receiving AI-driven suggestions

Where can I get help if I have issues installing Bito?

Contact for any assistance.

Bito AI chat is the most versatile and flexible way to use AI assistance. You can type any technical question to generate the best possible response. Check out these to understand all you can do with Bito.

To use AI Chat, type the question in the chat box, and press 'Enter' to send. You can add a new line in the question with 'SHIFT+ ENTER'.

Bito starts streaming answers within a few seconds, depending on the size and complexity of the prompt.

Bito makes it super easy to use the answer generated by AI, and take a number of actions.

Copy Answer

Copy the answer to the clipboard.

Regenerate Answer

AI may not give the best answer on the first attempt every time. You can ask Bito AI to regenerate the answer by clicking "Regenerate" button next to the answer.

Copy or Insert Code

If the AI answer includes a code snippet, Bito automatically identifies and displays code in a separate block. This makes it easy to copy the code to the clipboard or insert it in the code editor.

Rate Response

Vote response "Up" or "Down". This feedback Bito improve the prompt handling.

Modify Last Prompt

Many of these commands can be executed with keyboard shortcuts documented here:

When you open a project in Visual Studio Code or JetBrains IDEs, Bito lets you enable the of code files from that project’s folder. Basically, this indexing mechanism leverages our new that enables Bito to understand your entire codebase and answer any questions regarding it.

The index is stored locally on your system to provide better performance while maintaining the security/privacy of your private code.

How to Ask Questions?

Once indexing is complete, you can ask any question in the Bito chatbox. Bito uses AI to determine if you are asking about something in your codebase. If Bito is confident, it grabs the relevant parts of your code from our and feeds them to the for accurate answers. But if it's unsure, Bito will ask you to confirm before proceeding.

In case you ask a general question (not related to your codebase), then Bito will directly send your request to our LLM without first looking for the appropriate local context.

However, if you want to ask a question about your code no matter what, then you can use specific keywords such as "my code", "my repo", "my project", "my workspace", etc., in your question.

The complete list of these keywords is given on our page.

Once Bito sees any input containing these keywords, it will use the index to identify relevant portions of code or content in your folder and use it for processing your question, query, or task.

Security of your code

As usual, security is top of mind at Bito, especially when it comes to your code. A fundamental approach we have taken is to keep all code on your machine, and not store any code, code snippets, indexes, or on Bito’s servers or our API partners. All code remains on your machine, Bito does not store it. In addition, none of your code is used for AI model training.

Learn more about .

is an innovative tool that harnesses the power of functionality to automate software development workflows. It can automate repetitive tasks like software documentation, test case generation, pull request review, release notes generation, writing commit message or pull request description, and much more.

For example, you can run a command like bito –p writedocprompt.txt -f mycode.js for non-interactive mode in Bito CLI (where writedocprompt.txt will contain your prompt text such as Explain the code below in brief and mycode.js will contain the actual code on which the action is to be performed).

Download Bito CLI from GitHub:

With support for 50+ programming languages (Python, JavaScript, SQL, etc.) and 50+ spoken languages (English, German, Chinese, etc.), Bito CLI is versatile and adaptable to different project needs. Furthermore, it's designed to be compatible across multiple operating systems, including Windows, Mac, and Linux, ensuring a wide range of usability.

You can either use "ADVANCED" AI models like GPT-4o, Claude Sonnet 3.5, and best in class AI models, or "BASIC" AI models like GPT-4o mini and similar models inside Bito CLI.

When using Basic AI models, your prompts and the chat's memory are limited to 40,000 characters (about 18 single-spaced pages). However, with Advanced AI models, your prompts and the chat memory can go up to 240,000 characters (about 110 single-spaced pages). This means that Advanced models can process your entire code files, leading to more accurate answers.

If you are seeking the best results for complex tasks, then choose Advanced AI models.

Bito CLI is an invaluable asset for developers looking to increase efficiency and productivity in their workflows. It allows developers to save time and focus on more complex and creative aspects of their work. Additionally, Bito CLI plays a crucial role in supporting continuous integration and deployment (CI/CD) processes. Explore some we've created using Bito CLI, which you can implement in your projects right now. These automations showcase the powerful capabilities of Bito CLI.

To get started, check out our guide on , ensuring you make the most out of it.

Prerequisites

Terminal

• Bash (for Mac and Linux)

• CMD (for Windows)

Using Bito CLI

Before you can use Bito CLI, you need to and it. Once the setup is done, follow the steps below:

• Execute Chat: Run bito command on command prompt to get started. Ask anything you want help with such as awk command to print first and last column.

• Note: Bito CLI supports long prompts through multiline input. To complete and submit the prompt, press Ctrl+D. Enter/Return key adds a new line to the input.

• Exit Bito CLI: To quit/exit from Bito CLI, type quit and press Ctrl+D .

• Terminate: Press Ctrl+C to terminate Bito CLI.

Getting Started

Check out the video below to get started with Bito CLI.

Examples

Here are two examples for you to see My Prompt in action:

1. How to Create Git Commit Messages and Markdown Documentation with Ease using Bito CLI My Prompt:

1. How to generate test data using Bito CLI My Prompt:

Generative AI has been making waves across various sectors, from art to technology, leaving many people scratching their heads and wondering: WTF is Generative AI? In this guide, we'll unpack the buzzword and provide you with a clear understanding of what Generative AI is, how it works, and why it's becoming increasingly important in our digital world.

What is Generative AI?

At its core, Generative AI refers to the subset of artificial intelligence where the systems are designed to generate new content. It’s like giving an artist a canvas, but the artist is an algorithm that can create images, compose music, write text, generate programming source code, and much more.

Generative AI systems are typically powered by machine learning models that have been trained on vast datasets. They learn patterns, structures, and features from this data and use this understanding to generate new, original creations that are often indistinguishable from content created by humans.

How Does Generative AI Work?

Generative AI works using advanced machine learning models such as Generative Adversarial Networks (GANs) and Variational Autoencoders (VAEs).

These models involve two key components:

1. Generative Models: These are the AI algorithms that create the new data. For example, a generative model might create new images of animals it has never seen before by learning from a dataset of animal pictures.

2. Discriminative Models: In the case of GANs, the discriminative model evaluates the data generated by the generative model. This is like an art critic who tells the artist if their work is believable or not.

The two models work together in a sort of AI tug-of-war, with the generative model trying to produce better and better outputs and the discriminative model trying to get better at telling the difference between generated and real data.

Applications of Generative AI

Generative AI has a plethora of applications, here are a few:

• Art: Apps like DeepArt and platforms like DALL-E generate original visuals and art based on user prompts.

• Music: AI like OpenAI's Jukebox can generate music, complete with lyrics and melody, in various styles and genres.

• Text: Tools like ChatGPT can write articles, poetry, and even code based on text prompts. Bito also falls in this category as an AI Coding Assistant.

• Design: Generative AI can suggest design layouts for everything from websites to interior decorating.

• Deepfakes: This controversial use involves generating realistic video and audio recordings that can mimic real people.

Benefits and Challenges

Benefits

• Efficiency: Generative AI can produce content much faster than humans.

• Creativity: It has the potential to create novel combinations that might not occur to human creators.

• Personalization: AI can tailor content to individual tastes and preferences.

Challenges

• Ethics: Generative AI raises questions about authenticity and the ownership of AI-generated content.

• Quality Control: Ensuring consistent quality of AI-generated content can be challenging.

• Misuse: There’s a risk of its use in creating misleading information or deepfakes.

Future Prospects

The future of Generative AI is both exciting and uncertain. It could revolutionize how we create and consume content. For instance, imagine personalized movies generated in real-time to match your mood, or educational content adapted perfectly to each student's learning style.

As technology advances, so too will the capabilities of Generative AI. It's not just about the ‘WTF’ factor; it's about recognizing the potential and preparing for the transformation it will bring about.

Conclusion

Generative AI is at the frontier of innovation, standing at the crossroads of creativity and computation. It is transforming the conventional processes of creation across various fields and presenting us with a future where the line between human and machine-made is increasingly blurred. While it brings with it a host of benefits, we must tread carefully to navigate the ethical considerations and harness its power for the greater good.

As with any transformative technology, the question isn’t just 'WTF is Generative AI?' but also 'How do we responsibly integrate it into our society?' That is the real challenge and opportunity ahead.

A workspace is a dedicated environment or space where teams can collaborate and use Bito services. After logging into your Bito account, you can either create a new workspace or join an existing one you've been invited to.

Create a New Workspace

The link to create a new workspace will appear at the bottom of the sign-up flow screen. Click on "Create Workspace" to get started.

Now, enter the name of the workspace. You can also choose to make this workspace discoverable by the users with the same domain email as your email. Finally, click on the "Next" button to proceed creating a new workspace.

Once you complete the Workspace setup, Bito will be ready to use.

Join an Existing Workspace

If your email domain is allowed for the Workspace, or your coworker invited you, you will see the Workspace listed during the sign-up flow under the "Workspaces Available to Join" list.

Simply click on the "Join" button given in front of the workspace you want to join. Joining your company or team Workspace takes less than a minute.

Alternatively, you can join the Workspace through the Workspace link shared by your coworker.

Change Workspace

Follow the below steps to switch to a different workspace:

1. First log out of your Bito account.

1. Then, log back in and choose the workspace you want from the available list.

How to See Which Workspace You Are In?

In the IDE extension, place your mouse cursor over the workspace icon. The workspace name will show up as a tooltip.

You would need to create an account with your email to use Bito. You can sign up for Bito directly from the IDE extension or the Bito web interface at .

1. After you install the Bito extension, click the "Sign up or Sign-in" button on the Bito sign-up flow screen.

1. In the next screen, enter your work email address, and verify through a six-digit code sent to your email address.

1. Once your email is verified, you will get an option to create your profile. Enter your full name and set the language for the AI setup. Bito uses this setting to generate the output regardless of prompt language.

Now, let's learn to start using Bito.

Add or Update Billing Address

1. Open the page.

2. Click on the "Edit billing details" button. You will be redirected to a secure page powered by Stripe.
3. On this page, you will see your current plan details as well as billing information such as address. Click on "Update information" button to add/edit your billing details.

1. Now, you will see a form through which you can add your billing information such as the billing address and tax (VAT, GST, etc) details. Click on the "Save" button to save your changes or click on the "Cancel" button to return to the previous screen.

If your workspace is using the Free Plan, your account will not be charged when you invite new members. However, if your workspace has subscribed to the Team Plan, each member you invite will be charged based on the price of the Team Plan and the number of days and time left in the current month. Additionally, the 600 Advanced AI Model requests will be added to the total quota of the workspace for each member invited.

Read more at .

Inviting coworkers to the Workspace

1. Go to the page.

2. Click on the “Invite members” button.
3. A form will open in a popup box.

4. Enter emails of your coworkers that you want to add in the workspace.
5. Press the “Send” button to proceed.

6. A warning message will appear informing you that inviting new members to the workspace will result in additional charges.
7. If you are ok with that, press the “Invite members” button to send the invitation.

Keeping your Bito plugin up to date ensures you have access to the latest features and improvements. In this article, we will guide you through the steps to update the Bito plugin on both VS Code and JetBrains IDEs. Let's dive in!

Updating Bito Plugin on VS Code

1. Open your VS Code IDE

2. Navigate to the Extensions view by clicking on the square icon in the left sidebar

3. In the search bar, type "Bito" to locate the Bito plugin

4. Once you locate the Bito plugin, click on the update button to initiate the update

Pro Tip 💡: Enable Auto-update for Bito Plugin on VS Code (as shown in the video)

Updating Bito Plugin on JetBrains IDEs

1. Open your JetBrains IDE (e.g., IntelliJ IDEA, PyCharm, etc.)

2. Go to Settings by clicking on "File" in the menu bar (Windows/Linux) or by clicking on "IntelliJ IDEA" in the menu bar (macOS).

3. In the Settings window, navigate to the "Plugins" section

4. Switch to the "Installed" tab to view the list of installed plugins

5. Locate the Bito plugin in the list and click on the update button to initiate the update

This document explains some of Bito's privacy and security practices. Our Trust Center outlines our various accreditations (SOC 2 Type II) and our various security policies. You can read our full Privacy Policy at https://bito.ai/privacy-policy/.

Bito AI

Security is top of mind at Bito, especially when it comes to your code. A fundamental approach we have taken is we do not store any code, code snippets, indexes or embedding vectors on Bito’s servers unless you expressly allow it. You decide where you want to store your code, either locally on your machine, in your cloud, or on Bito’s cloud. Importantly, our AI partners do not store any of this information.

All requests are transmitted over HTTPS and are fully encrypted.

None of your code or AI requests are used for AI model training. None of your code or AI requests are stored by our AI partners. Our AI model partners are OpenAI, Anthropic, and Google. Here are their policies where they state that they do not store or train on data related to API access (we access all AI models via APIs):

1. OpenAI: https://openai.com/enterprise-privacy/

2. Anthropic: https://www.anthropic.com/uk-government-internal-ai-safety-policy-response/data-input-controls-and-audit

3. Google Cloud: https://cloud.google.com/blog/products/ai-machine-learning/google-cloud-unveils-ai-and-ml-privacy-commitment (5th paragraph)

The AI requests including code snippets you send to Bito are sent to Bito servers for processing so that we can respond with an answer.

Interactions with Bito AI are auto-moderated and managed for toxicity and harmful inputs and outputs.

Any response generated by the Bito IDE AI Assistant is stored locally on your machine to show the history in Bito UI. You can clear the history anytime you want from the Bito UI.

SOC 2 Type II Compliance

Bito is SOC 2 Type II compliant. This certification reinforces our commitment to safeguarding user data by adhering to strict security, availability, and confidentiality standards. SOC 2 Type II compliance is an independent, rigorous audit that evaluates how well an organization implements and follows these security practices over time.

Our SOC 2 Type II compliance means:

• Enhanced Data Security: We consistently implement robust controls to protect your data from unauthorized access and ensure it remains secure.

• Operational Excellence: Our processes are designed to maintain high availability and reliability, ensuring uninterrupted service.

• Regular Monitoring and Testing: We conduct continuous monitoring and regular internal reviews to uphold the highest security standards.

This certification is an assurance that Bito operates with a high level of trust and transparency, providing you with a secure environment for your code and data.

For any further questions regarding our SOC 2 Type II compliance or to request a copy of the audit report, please reach out to [email protected]

Code Flow through Bito’s System

AI Code Review Agent

When you use the self-hosted/docker version that you have setup in your VPC, in the docker image Bito checks out the diff and clones the repo for static analysis and also to determine relevant code context for code review. This context and the diff is passed to Bito's system. The request is then sent to a third-party LLM (e.g., OpenAI, Google Cloud, etc.). The LLM processes the prompt and return the response to Bito. No code is retained by the LLM. Bito then receives the response, processes it (such as formatting), and returns it to your self-hosted docker instance. This then posts it to your Git provider. However, the original query is not retained, nor are the results. After each code review is completed, the diff and the checked out repo are deleted.

If you use the Bito cloud to run the AI Code Review Agent, it runs similarly to the self-hosted version. Bito ephemerally checks out the diff and clones the repo for static analysis and to determine the relevant code context for code review. This context and the diff is passed to Bito's system. The request is then sent by Bito to a third-party LLM (e.g., OpenAI, Google Cloud, etc.). The LLM processes the prompt and return the response to Bito. No code is retained by the LLM. Bito then receives the response, processes it (such as formatting), and posts it to your Git provider. However, the original query is not retained, nor are the results. After each code review is completed, the diff and the checked out repo are deleted.

AI Chat and Code Completions

When we receive an AI request from a user, it is processed by Bito's system (such as adding relevant context and determining the Large Language Model (LLM) to use). However, the original query is not retained. The request is then sent to a third-party LLM (e.g., OpenAI, Google Cloud, etc.). The LLM processes the prompt and return the response to Bito. Bito then receives the response, processes it (such as formatting), and returns it to the user’s machine.

For enterprises, we have the ability to connect to your own private LLM accounts, including but not limited to OpenAI, Google Cloud, Anthropic, or third-party services such as AWS Bedrock, Azure OpenAI. This way all data goes through your own accounts or Virtual Private Cloud (VPC), ensuring enhanced control and security.

Data and Business Privacy Policy

In line with Bito's commitment to transparency and adherence to data privacy standards, our comprehensive data and business privacy policy is integrated into our practices. Our complete Terms of Use, including the Privacy Policy, are available at https://bito.ai/terms-of-use/, with our principal licensing information detailed at https://bito.ai/terms-of-service/.

Data Retention Policy

Our data retention policy is carefully designed to comply with legal standards and to respect our customers' privacy concerns. The policy is categorized into four levels of data:

1. Relationship and Usage Meta Data: This includes all data related to the customer's interaction with Bito, such as address, billing amounts, user account data (name and email), and usage metrics (number of queries made, time of day, length of query, etc.). This category of data is retained indefinitely for ongoing service improvement and customer support.

2. Bito Business Data: Includes customer-created templates and settings. This data is terminated 90 days after the end of the business relationship with Bito.

3. Confidential Customer Business Data: This includes code, code artifacts, and other organization-owned data such as Jira, Confluence, etc. This data is either stored on-prem/locally on the customer’s machines, or, if in the cloud, is terminated at the end of the business relationship with Bito.

4. AI Requests: Data in an AI request to Bito’s AI system. AI requests are neither retained nor viewed by Bito. We ensure the confidentiality of your AI queries; Bito and our LLM partners do not store your code, and none of your data is used for model training. All requests are transmitted via HTTPS and are fully encrypted.

Sub-processor

Bito uses the following third-party services: Amazon AWS, Anthropic, Clearbit, Github, Google Analytics, Google Cloud, HelpScout, Hubspot, Microsoft Azure, Mixpanel, OpenAI, SendGrid, SiteGround, and Slack for infrastructure, support, and functional capabilities.

Personal Data

Bito follows industry standard practices for protecting your e-mail and other personal details. Our password-less login process - which requires one-time passcode sent to your e-mail for every login - ensures the complete security of your account.

If you have any questions about our security and privacy, please email [email protected]

We are excited to announce that one of our users has developed a dedicated Vim and Neovim plugin for Bito, integrating it seamlessly with your favorite code editor. This plugin enhances your coding experience by leveraging the power of Bito's AI capabilities directly within Vim and Neovim.

Installation

To get started with "vim-bitoai," follow these steps:

Step 1: Install Bito CLI

Make sure you have Bito CLI installed on your system. If you haven't installed it, you can find detailed instructions in the Bito CLI repository at https://github.com/gitbito/CLI.

Step 2: Install the Plugin

Open your terminal and navigate to your Vim or Neovim plugin directory. Then, clone the "vim-bitoai" repository using the following command:

git clone https://github.com/zhenyangze/vim-bitoai.git

Step 3: Configure the Plugin

Open your Vim or Neovim configuration file and add the following lines:

" Vim Plug
Plug 'zhenyangze/vim-bitoai'

" NeoBundle
NewBundle 'zhenyangze/vim-bitoai'

" Vundle
Plugin 'zhenyangze/vim-bitoai'

Save the configuration file and restart your editor or run :source ~/.vimrc (for Vim) or :source ~/.config/nvim/init.vim (for Neovim) to load the changes.

Step 4: Verify the Installation

Open Vim or Neovim, and you should now have the "vim-bitoai" plugin installed and ready to use.

Usage

You can use its powerful features once you have installed the "vim-bitoai" plugin. Here are some of the available commands:

• BitoAiGenerate: Generates code based on a given prompt.

• BitoAiGenerateUnit: Generates unit test code for the selected code block.

• BitoAiGenerateComment: Generates comments for methods, explaining parameters and output.

• BitoAiCheck: Performs a check for potential issues in the code and suggests improvements.

• BitoAiCheckSecurity: Checks the code for security issues and provides recommendations.

• BitoAiCheckStyle: Checks the code for style issues and suggests style improvements.

• BitoAiCheckPerformance: Analyzes the code for performance issues and suggests optimizations.

• BitoAiReadable: Organizes the code to enhance readability and maintainability.

• BitoAiExplain: Generates an explanation for the selected code.

To execute a command, follow these steps:

1. Open a file in Vim or Neovim that you want to work on.

2. Select the code block you want to act on. You can use visual mode or manually specify the range using line numbers.

3. Execute the desired command by running the corresponding command in command mode. For example, to generate code based on a prompt, use the : BitoAiGenerate command. Note: Some commands may prompt you for additional information or options.

4. The plugin will communicate with the Bito CLI and execute the command, providing the output directly within your editor.

By leveraging the "vim-bitoai" plugin, you can directly harness the power of Bito's AI capabilities within your favorite Vim or Neovim editor. This integration lets you streamline your software development process, saving time and effort in repetitive tasks and promoting efficient coding practices.

Customization

The "vim-bitoai" plugin also offers customization options tailored to your specific needs. Here are a few variables you can configure in your Vim or Neovim configuration file:

• g:bito_buffer_name_prefix: Sets the prefix for the buffer name in the Bito history. By default, it is set to 'bito_history_'.

• g:vim_bito_path: Specifies the path to the Bito CLI executable. If the Bito CLI is not in your system's command path, you can provide the full path to the executable.

• g:vim_bito_prompt_{command}: Allows you to customize the prompt for a specific command. Replace {command} with the desired command.

To define a custom prompt, add the following line to your Vim or Neovim configuration file and replace your prompt with the desired prompt text:

if !exists("g:vim_bito_prompt_{command}")
    let g:vim_bito_prompt_{command}="your prompt"
endif

Remember to restart your editor or run the appropriate command to load the changes.

We encourage you to explore the "vim-bitoai" plugin and experience the benefits of seamless integration between Bito and your Vim or Neovim editor. Feel free to contribute to the repository or provide feedback to help us further improve this plugin and enhance your coding experience.

Here is the list of keywords in different languages to ask questions regarding your entire codebase. Use any of these keywords in your prompts inside Bito chatbox.

English:

• my code

• my repo

• my project

• my workspace

Chinese:

• 我的代码

• 我的仓库

• 我的代码库

• 我的项目

• 我的文件夹

Chinese Traditional:

• 我的程式碼

• 我的倉庫

• 我的項目

• 我的工作區

Spanish:

• Mi código

• Mi repo

• Mi proyecto

• Mi espacio de trabajo

Japanese:

• 私のコード

• 私のリポ

• 私のプロジェクト

• 私のワークスペース

Portuguese:

• Meu código

• Meu repo

• Meu projeto

• Meu espaço de trabalho

Polish

• Mój obszar roboczy

• moje miejsce pracy

• mój obszar roboczy

• moj kod

• mój kod

• moim kodzie

• moje repo

• moje repozytorium

• moim repo

• moj projekt

• mój projekt

• moim projekcie

Large Language Models (LLMs) are advanced AI algorithms trained to understand, generate, and sometimes translate human language. They are called “large” for a good reason: they consist of millions or even billions of parameters, which are the fundamental data points the model uses to make predictions and decisions.

How Do LLM Work?

Imagine teaching a child language by reading every book you can find. That’s essentially what LLMs go through. They are fed vast amounts of text data and use statistical methods to find patterns and learn from context. Through a process known as machine learning, these models become adept at predicting the next word in a sentence, answering questions, summarizing texts, and more.

The Training Regime

Data, Data, and More Data: LLMs are the heavyweight champions of the data world. They are trained on diverse datasets comprising encyclopedias, books, articles, and websites to learn a wide range of language patterns and concepts.

Supervised and Unsupervised Learning: Some LLMs learn through supervised learning, meaning they learn from datasets that have been labeled or corrected by humans. Others use unsupervised learning, meaning they infer patterns and rules from raw data without human annotation.

Fine-Tuning: After the initial training, LLMs can be fine-tuned for specific tasks, like legal document analysis or medical diagnosis, by training them further on specialized data.

Applications of LLMs

Writing Assistance: Grammarly or the autocomplete in your email are powered by LLMs. They predict what you’re trying to say and help you say it better.

Chatbots: If you've ever chatted with Bito and noticed that it sounds almost like a real person, that's because it is powered by several state-of-the-art Large Language Models.

Translation Services: Services like Google Translate use LLMs to convert text from one language to another, learning from vast amounts of bilingual text to improve their accuracy.

The Magic Behind the Scenes

Neural Networks: The core technology behind LLMs is artificial neural networks, particularly a type called Transformer models. These mimic some aspects of human brain function and are particularly good at handling sequential data like text.

Training Hardware: Training LLMs requires significant computational power, often involving hundreds of GPUs or specialized TPUs that work in tandem for weeks or months.

Continuous Learning: LLMs don’t stop learning after their initial training. They can continue to learn from new data, improving their performance over time.

Examples of Large Language Models

GPT Series by OpenAI

The GPT series by OpenAI has been a trailblazer in the field of LLMs. Each version of the Generative Pre-trained Transformer has been more powerful than the last, with GPT-4o as a staggering leap forward. Boasting over 200 billion parameters, this model is not just about size; it’s about the nuanced understanding and generation of human-like text. GPT-4o can craft essays that are indistinguishable from those written by humans, compose complex poetry, and even generate functional computer code across several languages, which is a testament to its versatility.

GPT-4o's influence extends across industries. For instance, it can simulate conversations, create educational content, and even assist programmers by converting natural language descriptions into code snippets. Its advanced capabilities are being integrated into various software applications and tools, enhancing productivity and sparking creative new approaches to problem-solving.

BERT by Google

BERT stands for Bidirectional Encoder Representations from Transformers. It's a complicated name, but really, it's just Google's method for making search engines smarter. Unlike earlier models, BERT examines the context of a word in both directions (left and right of the word) within a sentence, leading to a far more nuanced interpretation of the query. This ability means that BERT can grasp the full intent behind your searches, so the results you get are closer to what you actually need.

Since its integration into Google's search engine, BERT has significantly improved the relevance of results for millions of queries every day. For users, this often translates to finding answers more quickly and accurately, sometimes in subtle ways that may go unnoticed but are nonetheless powerful. Beyond search, BERT is also revolutionizing natural language processing tasks such as language translation, question answering, and text summarization.

In summary, both the GPT series and BERT are not just steps but giant leaps forward in our ability to interface with machines in a more natural, intuitive way. They are redefining what's possible in the realm of AI and continuing to pave the way for smarter, more responsive technology.

Ethical Considerations and Challenges

Bias in AI: Since LLMs learn from existing data, they can perpetuate and amplify biases present in that data. It’s an ongoing challenge to ensure that LLMs are fair and unbiased.

Privacy: Training LLMs on personal data raises privacy concerns. Ensuring data used is anonymized and secure is paramount.

Environmental Impact: The energy consumption of training and running LLMs is significant. Researchers are working on more efficient models to mitigate this.

The Future of LLMs

Evolving Intelligence: LLMs are getting more sophisticated, with future models expected to handle more complex tasks and exhibit greater understanding of human language.

Interdisciplinary Integration: LLMs are beginning to intersect with other fields, such as bioinformatics and climatology, providing unique insights and accelerating research.

Democratization of AI: As LLMs become more user-friendly, their use is expanding beyond tech companies to schools, small businesses, and individual creators.

Conclusion

Large Language Models are transforming how we interact with machines, making them more human-like than ever. They're a blend of colossal data, computing power, and intelligent algorithms, pushing the boundaries of what machines can understand and accomplish. As they evolve, LLMs will continue to shape our digital landscape in unpredictable and exciting ways. Just remember, the next time you type out a sentence and your phone suggests the end of it, there’s a little bit of LLM magic at work.

We understand that the security of your payment information is of utmost importance. That's why we have partnered with Stripe, a globally recognized and trusted payment platform, to ensure that your sensitive data remains safe and secure throughout the payment process.

If you have any questions, please contact us at [email protected]

Why Stripe?

When you subscribe to our paid plans, we rely on Stripe's robust infrastructure to handle your payment details securely.

Here's why we chose Stripe as our trusted payment handler:

1. PCI Compliance

Stripe is certified as a Level 1 Service Provider under the Payment Card Industry Data Security Standard (PCI DSS). It is the most stringent level of certification available in the payment industry. This means that Stripe adheres to strict security standards and undergoes regular audits to ensure compliance.

It ensures that all cardholder data is handled securely throughout the payment journey.

Rest assured that your sensitive card information is securely handled at all times. Neither Bito nor Stripe stores your sensitive data on their servers. Even our staff cannot access it. Your payment details are safe with us.

2. GDPR Compliance

Stripe also complies with the General Data Protection Regulation (GDPR) and regularly undergoes audits to maintain its certifications.

3. Secure API Communication

All communication between Bito and Stripe occurs through secure APIs (Application Programming Interfaces). These APIs are designed to transmit data in an encrypted format, adding an extra layer of security to the payment process.

4. Data Encryption

All data transmitted to Stripe is encrypted using industry-standard encryption protocols, such as TLS (Transport Layer Security). This ensures that sensitive information, including credit card details and personal data, is protected during transit.

5. Secure Card Information Handling

Stripe follows the principle of "security by design" and does not store cardholder data on its servers. Instead, it utilizes tokenization, a process that replaces sensitive card information with unique tokens. These tokens are used for subsequent transactions, reducing the risk of unauthorized access to card data.

This means that even if Stripe's systems were compromised, your original card information would remain safe as the token holds no value to potential attackers.

6. Intrusion Detection and Prevention

Stripe maintains a comprehensive intrusion detection and prevention system to monitor and block any unauthorized attempts to access its systems. Suspicious activities are flagged in real-time, and appropriate action is taken to mitigate potential threats.

7. Radar Fraud Detection

Stripe's Radar uses machine learning algorithms to detect and prevent fraudulent transactions in real-time. This intelligent system constantly evolves and adapts to new fraud patterns, providing enhanced protection for Bito's customers.

8. Continuous Monitoring

Stripe conducts regular security assessments and audits to identify vulnerabilities and address potential weaknesses in its systems. This continuous monitoring approach allows them to stay proactive in the face of emerging security risks.

Unlock the power of AI-driven code reviews in VS Code, Cursor, Windsurf, and all JetBrains IDEs (including IntelliJ IDEA, PyCharm, WebStorm, and more) with Bito's AI Code Review Agent. This tool provides real-time, human-like feedback on your code changes, catching common issues before you submit a pull request.

The AI Code Review Agent helps you improve your code as you develop, so you don't have to wait for days to get feedback. This accelerates development cycles, boosts team productivity, and ensures higher code quality.

You can start using the Agent immediately—no setup is required!

Install on VS CodeInstall on JetBrainsInstall on CursorInstall on Windsurf

Prerequisites

1. Install the latest Bito IDE extension for VS Code, JetBrains, Cursor, or Windsurf.

2. A workspace subscribed to the Bito Team Plan. Read documentation on how to upgrade.

1. The root of your project must be a Git repository and opened in the supported IDE.

How to use the Agent in IDE?

1. Open the Bito IDE extension.

2. Login to your workspace subscribed to the Bito Team Plan.

3. Type @codereview in the chat box to open a menu and select from the following actions:

   • localchanges: Review local changes

   • stagedchanges: Review staged changes

   • path: Review a single file or multiple files

   • commitId: Review a single commit or a range of commits

1. After that, choose between Essential and Comprehensive review modes:

   • In Essential mode, only critical issues are posted.

   • In Comprehensive mode, Bito also includes minor suggestion and potential nitpicks.

2. Submit to get the code review feedback.

Start code review from context menu

You can also invoke the AI Code Review Agent directly from the context menu by right-clicking in the code editor and selecting commands under the "Bito Code Review Agent" menu.

This provides faster, on-the-go access to code reviews right where you work.

Reviewing the feedback

Once the AI code review is complete, you'll receive a notification in the IDE. You can view the feedback in the Bito Panel, which includes a list of issues and their fixes.

Each item will contain the following details:

• Issue description: Description of the identified issue.

• Fix description: Recommended approach or steps to resolve the issue.

• File path: The file containing the issue.

• Code suggestion: The AI-generated code fix for the issue.

Code review session history

To view past code reviews, click the Session history icon in the top-right corner of the Bito Panel. This opens the Session history tab, which lists all your previous code review sessions.

From the list, click any session to open it and view the complete code review details along with the AI suggestions.

Get up and running with Bito in just a few steps! Bito seamlessly integrates with Visual Studio Code, providing powerful AI-driven code reviews directly within your editor. Click the button below to quickly install the Bito extension and start optimizing your development workflow with context-aware AI Chat, and more.

Video guide

Watch the video below to learn how to download the Bito extension on VS Code.

Step-by-step instructions

1. In Visual Studio Code, go to the extension tab and search for Bito.

1. Install the extension. We recommend you restart the IDE after the installation is complete.

1. After a successful install, the Bito logo appears in the Visual Studio Code pane.

1. Click the Bito logo to launch the extension and complete the setup process. You will either need to create a new workspace if you are the first in your company to install Bito or join an existing workspace created by a co-worker. See Managing workspace members

Setup Bito extension in VS Code running through SSH

SSH (Secure Shell) is a network protocol that securely enables remote access, system management, and file transfer between computers over unsecured networks.

Visual Studio Code IDE allows developers to access and collaborate on projects from any connected machine remotely. The corresponding extension [Remote -SSH] must be installed on the host machine's Visual Studio Code IDE to utilize this feature.

The Bito VS Code extension seamlessly integrates with Remote development via SSH, allowing developers to utilize Bito features and capabilities on their remote machines.

Remote SSH connection and setup

Please follow the instructions given in the links below:

• https://code.visualstudio.com/docs/remote/ssh

• https://learn.microsoft.com/en-us/windows-server/administration/openssh/openssh_install_firstuse

Video Guide:

Setup Bito extension in VS Code running through WSL

Running VS Code on WSL allows developers to work in a Linux-like environment directly from Windows. This kind of setup is to take advantage of development experience on both operating systems.

WSL provides access to Linux command-line tools, utilities, and applications, to enhance productivity and streamline the development process.

This setup ensures a consistent development environment across different systems, making it easier to develop, test, and deploy applications that will run on Linux servers.

WSL connection and setup

Please follow the instructions given in the links below:

• https://code.visualstudio.com/docs/remote/wsl-tutorial

• https://learn.microsoft.com/en-us/windows/wsl/install

Video Guide:

Easily share insights from any AI Chat session by creating a unique shareable link directly from the Bito extension in VS Code or JetBrains IDEs.

Whether you need to share AI-generated code suggestions, explanations, or any other chat insights, this feature allows you to create a public link that others can access. The link will remain active for 15 days and can be viewed by anyone with access to the URL, making collaboration and knowledge sharing seamless.

Additionally, you can quickly share your AI Chat session through a pre-written Tweet or an Email.

Let's see how it is done:

1. Open Bito in Visual Studio Code or any JetBrains IDE.

2. Start a conversation in Bito’s AI Chat user interface.

3. Locate the share button on the top right of the Bito extension side-panel.

4. Click the share button to open a menu with options, including X (Twitter), Email, and Link.

5. Share on X (Twitter):

   1. Click on X (Twitter) from the menu, and a dialogue window will appear, asking whether you want to open the external site.

   2. Simply click "Open" to proceed.

   3. You will be redirected to the X (Twitter) website, with a pre-written tweet containing a link to your Chat Session ready to be published.

   4. Click the "Post" button to send the tweet.

6. Share Through Email:

   1. Click on Email from the menu, and you will be redirected to your email application.

   2. Select your email account if needed.

   3. The email will be pre-filled with all the necessary information, including the link to your Chat Session.

   4. Add the receiver(s) of this email using the "To" input field.

   5. Click the "Send" button to send the email.

7. Share the Link:

   1. Click on Link from the menu.

   2. A confirmation popup will appear. Click Share session to generate a unique URL for your chat session, which will automatically be copied to your clipboard for easy sharing.

   3. Feel free to share this link with anyone you'd like to.

Bito users come from all over the world, and it makes it super easy to set the AI output language. Bito will automatically generate the text output in the language in your user profile setting, regardless of the prompt input language.

Bito allows setting this language when creating an account, as described in Creating a Bito account.

You can also set or change this setting anytime by going to Settings > Profile settings in Bito Cloud. Here is a quick video walkthrough.

Supported Languages:

Bito offers 20+ languages for you to choose from. Here is the list of currently supported languages:

1. English (Default Language)

2. Bulgarian (български)

3. Chinese (Simplified) (简体中文)

4. Chinese (Traditional) (繁體中文)

5. Czech (čeština)

6. French (français)

7. German (Deutsch)

8. Hungarian (magyar)

9. Italian (italiano)

10. Japanese (日本語)

11. Korean (한국어)

12. Polish (polski)

13. Portuguese (português)

14. Russian (русский)

15. Spanish (español)

16. Turkish (Türkçe)

17. Vietnamese (Tiếng Việt)

18. Dutch (Nederlands)

19. Hebrew (עִברִית)

20. Arabic (عربي)

21. Malay (Melayu)

22. Hindi (हिंदी)

Using the Language Support Feature

Once you have selected your preferred language, Bito will communicate with you in your selected language. Take full advantage of this feature by:

• Asking questions or giving commands to Bito in your selected language

• Receiving responses and outputs from Bito in the language you've selected

Note: All responses from Bito will appear in the selected language, regardless of the input language

Enjoy the convenience of conversing with Bito in your native language and take your coding experience to a new level!

Bito’s is the first agent built with Bito’s AI Agent framework and engine. It is an automated AI assistant (powered by Anthropic’s Claude Sonnet 3.7) that will review your team’s code; it spots bugs, issues, code smells, and security vulnerabilities in Pull/Merge Requests (PR/MR) and provides high-quality suggestions to fix them.

It seamlessly integrates with Git providers such as GitHub, GitLab, and Bitbucket, automatically posting recommendations directly as comments within the corresponding Pull Request. It includes real-time recommendations from Static Code Analysis and OSS vulnerability tools such as fbinfer, Dependency-Check, etc. and can include high severity suggestions from other 3rd party tools you use such as Snyk.

The AI Code Review Agent acts as a set of specialized engineers each analyzing different aspects of your PR. They analyze aspects such as Performance, Code Structure, Security, Optimization, and Scalability. By combining and filtering the results, the Agent can provide you with much more detailed and insightful code reviews, bringing you a better quality code review and helping you save time.

The AI Code Review Agent helps engineering teams merge code faster while also keeping the code clean and up to standard, making sure it runs smoothly and follows best practices.

It ensures a secure and confidential experience without compromising on reliability. Bito neither reads nor stores your code, and none of your code is used for AI model training. Learn more about our .

By accessing Bito's feature, the AI Code Review Agent can analyze relevant context from your entire repository, providing better context-aware analysis and suggestions. This tailored approach ensures a more personalized and contextually relevant code review experience.

To comprehend your code and its dependencies, we use Symbol Indexing, Abstract Syntax Trees (AST), and Embeddings. Each step feeds into the next, starting from locating specific code snippets with Symbol Indexing, getting their structural context with AST parsing, and then leveraging embedding vectors for broader semantic insights. This approach ensures a detailed understanding of the code's functionality and its dependencies. For more information, see

The AI Code Review Agent is built using Bito Dev Agents, an open framework and engine to build custom AI Agents for software developers that understands code, can connect to your organization’s data and tools, and can be discovered and shared via a global registry.

Why use an AI Agent for code review?

In many organizations, senior developers spend approximately half of their time reviewing code changes in PRs to find potential issues. The AI Code Review Agent can help save this valuable time.

AI Code Review Agent speeds up PR merges by 89%, reduces regressions by 34%, and delivers 87% human-grade feedback.

However, it's important to remember that the AI Code Review Agent is designed to assist, not replace, senior software engineers. It takes care of many of the more mundane issues involved in code review, so senior engineers can focus on the business logic and how new development is aligned with your organization’s business goals.

Pricing details

The Free Plan offers AI-generated pull request summaries to provide a quick overview of changes. For advanced features like line-level code suggestions, consider upgrading to the Team Plan. For detailed pricing information, visit our page.

Learn more

Minimum System Requirements

A machine with the following minimum specifications is recommended for Docker image deployment and for obtaining optimal performance of the AI Code Review Agent.

Supported Operating Systems

• Windows

• Linux

• macOS

OS Prerequisites

Required Access Tokens

• Bito Access Key: Obtain your Bito Access Key.

• GitHub Personal Access Token (Classic): For GitHub PR code reviews, ensure you have a CLASSIC personal access token with repo access. We do not support fine-grained tokens currently.

• GitLab Personal Access Token: For GitLab PR code reviews, a token with API access is required.

• Snyk API Token (Auth Token): For Snyk vulnerability reports, obtain a Snyk API Token.

The offers a suite of commands tailored to developers' needs. You can manually trigger a code review by entering any of these commands in the comment box below a pull/merge request on GitHub, GitLab, or Bitbucket and submitting the comment. Alternatively, if you are using the self-hosted version, you can configure these commands in the for automated code reviews.

/review

This command provides a broad overview of your code changes, offering suggestions for improvement across various aspects but without diving deep for secure coding or performance optimizations or scalability improvements etc. This makes it ideal for catching general code quality issues that might not necessarily be critical blockers but can enhance readability, maintainability, and overall code health.

Think of it as a first-pass review to identify potential areas for improvement before delving into more specialized analyses.

Review Scope

Five specialized commands are available to perform detailed analyses on specific aspects of your code. Details for each command are given below.

1. /review security

2. /review performance

3. /review scalability

4. /review codeorg

5. /review codeoptimize

Combining general feedback with specialized review scopes

If you'd like to receive general code quality feedback alongside specialized analyses, include the general keyword in your review command.

For example, to receive feedback on general code quality, performance, and security, use:

• Example: /review general,performance,security

This ensures a holistic review encompassing both general code quality and specific areas of concern.

/review security

This command performs an in-depth analysis of your code to identify vulnerabilities that could allow attackers to steal data, gain unauthorized access, or disrupt your application. This includes checking for weaknesses in input validation, output encoding, authentication, authorization, and session management. It also looks for proper encryption of sensitive data, secure coding practices, and potential misconfigurations that could expose your system.

/review performance

This command evaluates the current performance of the code by pinpointing slow or resource-intensive areas and identifying potential bottlenecks. It helps developers understand where the code may be underperforming against expected benchmarks or standards. It is particularly useful for identifying slow processes that could benefit from further investigation and refinement.

This includes checking how well your code accesses data and manages tasks like database interactions and memory usage.

/review scalability

This command analyzes your code to identify potential roadblocks to handling increased usage or data. It checks how well the codebase supports horizontal scaling and whether it is compatible with load balancing strategies. It also ensures the code can handle concurrent requests efficiently and avoids bottlenecks from single points of failure. The command further examines error handling and retry mechanisms to promote system resilience under pressure.

/review codeorg

This command scans your code for readability, maintainability, and overall clarity. This includes checking for consistent formatting, clear comments, well-defined functions, and efficient use of data structures. It also looks for opportunities to reduce code duplication, improve error handling, and ensure the code is written for future growth and maintainability.

/review codeoptimize

This command helps identify specific parts of the code that can be made more efficient through optimization techniques. It suggests refactoring opportunities, algorithmic improvements, and areas where resource usage can be minimized. This command is essential for enhancing the overall efficiency of the code, making it faster and less resource-heavy.

Control code review workflow

These commands allow you to manage the AI Code Review Agent's behavior directly within your pull requests across GitHub, GitLab, and Bitbucket.

/pause

Pauses automatic AI reviews on the current pull request.

Use case: Useful when significant changes are underway, and you want to prevent the AI from reviewing incomplete code.

Example: Add a comment with /pause to the pull request.

/resume

Resumes the automatic AI reviews that were previously paused on the pull request.

Use case: Once your code changes are ready for review, use this command to re-enable the AI's automatic analysis.

Example: Add a comment with /resume to the pull request.

/resolve

Marks all Bito-posted review comments as resolved.

Use case: After addressing the issues highlighted by the AI, use this command to clean up the comment threads.

Example: Add a comment with /resolve to the pull request.

/abort

Cancels all in-progress AI code reviews on the current pull request.

Use case: If an AI review is no longer needed or was initiated by mistake, this command stops the process.

Example: Add a comment with /abort to the pull request.

Display Code Review in a Single Post

By default, the /review command generates inline comments, placing code suggestions directly beneath the corresponding lines in each file for clearer guidance on improvements. If you prefer a single consolidated code review instead of separate inline comments, use the #inline_comment parameter and set its value to False.

Example: /review #inline_comment=False

Example: /review scalability #inline_comment=False

Bito integrates with Jira to automatically validate pull request code changes against linked Jira ticket requirements, helping ensure your implementations align with the specified requirements in those tickets.

How it works

When you create a pull request, Bito automatically:

1. Detects Jira ticket references in your pull request description, title, or branch name

2. Crawls the linked Jira tickets to extract requirements from issue descriptions and related Stories/Epics

3. Analyzes your code changes against these requirements

4. Provides structured validation results directly in your pull request comments

Setting up Jira integration

Linking Jira tickets to pull requests

Bito offers multiple ways to link your Jira tickets with pull requests. You can use any of these methods:

Method 1: Branch name

Name your source branch using the Jira issue key:

Method 2: Pull request description

Include the Jira ticket reference in your PR description:

OR

Method 3: Pull request title

Include the Jira issue key in your PR title:

Understanding the validation results

When Bito completes its analysis, it adds a "Functional Validation by Bito" table to your pull request comments. This table contains four columns:

Source

Displays the Jira issue key (e.g., "QP-11", "QP-123") that references the specific Jira ticket being validated.

Requirement / Code Area

Shows a brief description of the requirement or task that needs to be completed, summarizing what needs to be done according to the Jira ticket.

Status

Indicates the completion status of each requirement:

• Met: The requirement has been fully implemented in the pull request

• Missed: The requirement has not been addressed in the pull request

• Partial: The requirement has been partially implemented but still needs additional work

Notes

Provides detailed information about the validation status:

• For "Met" items: Explains what has been successfully implemented

• For "Missed" items: Describes what is missing and needs to be addressed

• For "Partial" items: Details what has been completed and what still remains to be done

Example validation output

Here's what a typical validation table looks like:

Benefits

• Automated quality assurance: Ensure code changes meet specified requirements

• Improved collaboration: Bridge the gap between project management and development

• Reduced manual reviews: Bito AI automatically catches missing implementations during code review

• Better traceability: Maintain clear links between requirements and code changes

By leveraging Bito's Jira integration, your development team can maintain higher code quality while ensuring that all requirements are properly addressed in every pull request.

Best practices

For developers

• Always reference Jira tickets in your pull requests using one of the supported methods

• Review the validation table and address any "Missed" or "Partial" items before merging

For teams

• Ensure Jira tickets contain clear, detailed requirements

• Use consistent naming conventions for branches and pull request titles

• Enable functional validation for all relevant agents

Troubleshooting

Validation table not appearing:

• Check that your Jira integration is properly configured in the page

• Verify that Functional validation is enabled in your agent settings

• Ensure your pull request contains valid Jira issue key references

Incorrect validation results:

• Review your Jira ticket descriptions for clarity and completeness

• Verify that linked Stories/Epics contain relevant requirements

• Check that your code changes are in the expected areas

Bito's supports different configuration methods depending on the deployment environment:

1. Bito-hosted – The agent runs on Bito's infrastructure and is configured through the .

2. Self-hosted – The agent runs on user-managed infrastructure and is configured by editing the .

The sections below provide configuration guidance for each setup.

Bito-hosted agent configuration

In Bito-hosted AI Code Review Agent, you can configure the agent through the .

To customize an existing agent, open the page and click the Settings button next to the Agent instance to be modified.

The agent settings page allows configuration of options such as:

• Agent name – Define a unique name for easy identification.

• Review options – Choose the review mode (Essential or Comprehensive), set feedback language, and enable features like auto-review, incremental review, summaries, and change walkthroughs.

• Custom guidelines – Create and apply custom code review rules tailored to your team’s standards directly from the dashboard.

• Filters – Exclude specific files, folders, or branches from review to focus on relevant code.

• Tools – Enable additional checks, such as secret scanning and static analysis.

• Chat – Configure how the agent responds to follow-up questions in pull request comments and manage automatic replies.

These settings tailor the agent’s behavior to match team workflows and project needs. For detailed guidance, see .

Self-hosted agent configuration

In self-hosted deployments, configuration is managed by editing the . This file defines how the agent operates and connects to required services.

Key configuration options include:

• Mode

  • mode = cli: Processes a single pull request using a manual URL input.

  • mode = server: Runs as a webhook service and listens for incoming events from Git platforms.

• Authentication

  • bito_cli.bito.access_key: Required for authenticating the agent with the Bito platform.

  • git.provider, git.access_token, etc.: Required for connecting to the appropriate Git provider (e.g., GitHub, GitLab, Bitbucket).

• General feedback settings

  • code_feedback: Enables or disables general feedback comments in reviews.

• Analysis tools

  • static_analysis: Enables static code analysis.

  • dependency_check: Enables open-source dependency scanning.

  • dependency_check.snyk_auth_token: Required when using Snyk for vulnerability detection.

• Review format and scope

  • review_comments: Defines output style (e.g., single post or inline comments).

  • review_scope: Limits the review focus to specific concerns such as security, performance, or style.

• Filters

  • include_source_branches and include_target_branches: Restrict reviews to pull requests that match specified source and target branch patterns.

  • exclude_files: Skips selected files based on glob patterns.

  • exclude_draft_pr: Skips draft pull requests when enabled (default: True).

Each property is documented in detail on the page.

Generating the best possible response is as much science as art. The are built on the same technology as ChatGPT handles the science part. Crafting a good is the art part. The Templates in Bito takes the burden off your shoulder in being crafty. You can select a piece of code and use one of the eight prompts, whether you want to check the code for performance or add error handling. Behind-the-scene actor "Bito Prompt Manager" crafts a well-versed prompt that squeezes the best response out of the machine.

Templates are accessible:

1- In the Bito panel

Click on the Templates button to expand or collapse Templates menu.

2- Using Slash / Command in Bito Chat Box

Type a forward slash / right at the start in the Bito chat box. Once you do, the template menu will open from where you can quickly select and use the template you want.

Want to narrow down your choices? Simply start typing after the / slash, and it'll only show you templates that match your words. And hey, you can also use the arrow keys, or Tab and Shift + Tab, to navigate the templates menu.

3- From the Code Editor's Context Menu

Select code, right click, and click Bito AI to access shortcuts

4- Through the Command Palette in Visual Studio Code

Go to View -> Command Palette -> Type "Bito" to access the templates

The following Loom demonstrates Standard Templates in Bito:

Bito includes the following standard templates out of the box.

Installing Bito CLI (Recommended)

We recommend you use the following methods to install Bito CLI.

Mac and Linux

sudo curl https://alpha.bito.ai/downloads/cli/install.sh -fsSL | bash

Note: curl will always download the latest version.

Archlinux

Arch and Arch based distro users can install it from

yay -S bito-cli

or

paru -S bito-cli

Note for the Mac Users: You might face issues related to verification for which you will have to manually do the steps from (we are working on fixing it as soon as possible).

Windows

• In the , open the folder that has the latest version number.

• From here, download the MSI file called Bito CLI.exe and then install Bito CLI using this installer.

• On Windows 11, you might get notification related to publisher verification. Click on "Show more" or "More info" and click on "Run anyway" (we are working on fixing this as soon as possible).

Installing with Manual Binary Download (Not Recommended)

While it's not recommended, you can download the Bito CLI binary from our repository, and install it manually. The binary is available for Windows, Linux, and Mac OS (x86 and ARM architecture).

Mac and Linux

1. In the , open the folder that has the latest version number.

2. From here, download the Bito CLI binary specific to your OS platform.

3. Start the terminal, go to the location where you downloaded the binary, move the downloaded file (in the command below use bito-* filename you have downloaded) to filename bito.

   mv bito-<os>-<arch> bito

4. Make the file executable using following command chmod +x ./bito

5. Copy the binary to /usr/local/bin using following command sudo cp ./bito /usr/local/bin

6. Set PATH variable so that Bito CLI is always accessible. PATH=$PATH:/usr/local/bin

7. Run Bito CLI with bito command. If PATH variable is not set, you will need to run command with the complete or relative path to the Bito executable binary.

Windows

1. In the , open the folder that has the latest version number.

2. From here, download the Bito CLI binary for Windows called bito.exe.

3. For using Bito CLI, always move to the directory containing Bito CLI prior to running it.

4. Set PATH variable so that Bito CLI is always accessible.

   1. Follow the instructions as per this

   2. Edit the "Path" variable and add a new path of the location where Bito CLI is installed on your machine.

Uninstalling Bito CLI

Mac and Linux

sudo curl https://alpha.bito.ai/downloads/cli/uninstall.sh -fsSL | bash

Note: This will completely uninstall Bito CLI and all of its components.

Windows

For Windows, you can uninstall Bito CLI just like you uninstall any other software from the control panel. You can follow these steps:

1. Click on the Windows Start button and type "control panel" in the search box, and then open the Control Panel app.

2. Under the "Programs" option, click on "Uninstall a program".

3. Find "Bito CLI" in the list of installed programs and click on it.

4. Click on the "Uninstall" button (given at the top) to start the uninstallation process.

5. Follow the instructions provided by the uninstall wizard to complete the uninstallation process.

After completing these steps, Bito CLI should be completely removed from your Windows machine.

Help

Run any one of the below commands.

bito --help

or

bito config –help

Check Bito CLI Version

Run any one of the below commands to print the version number of Bito CLI installed currently.

bito -v

or

bito --version

Bito CLI MyPrompt (Automation using Bito CLI)

The below commands can help you automate repetitive tasks like software documentation, test case generation, writing pull request description, pull request review, release notes generation, writing commit message, and much more.

1- Non-Interactive Mode with File Input

Run the below command for non-interactive mode in Bito (where writedocprompt.txt will contain your prompt text such as Explain the code below in brief and mycode.js will contain the actual code on which the action is to be performed).

2- Standard Input Mode

Run the below command to read the content at standard input in Bito (where writedocprompt.txt will contain your prompt text such as Explain the code below in brief and input provided will have the actual content on which the action is to be performed).

3- Direct File Input

Run the below command to directly concatenate a file and pipe it to bito and get instant result for your query.

On Mac/Linux

On Windows

4- Redirect Output to a File

On Mac/Linux

Run the below command to redirect your output directly to a file (where -p can be used along with cat to perform prompt related action on the given content).

On Windows

Run the below command to redirect your output directly to a file (where -p can be used along with type to perform prompt related action on the given content).

5- Store Context/Conversation History

Run the below command to store context/conversation history in non-interactive mode in file runcontext.txt to use for next set of commands in case prior context is needed. If runcontext.txt is not present it will be created. Please provide a new file or an existing context file created by bito using -c option. With -c option now context is supported in non-interactive mode

On Mac/Linux

On Windows

6- Instant Response for Queries

Run the below command to instantly get response for your queries using Bito CLI.

Using Comments

Anything after # symbol in your prompt file will be considered as a comment by Bito CLI and won't be part of your prompt.

You can use \# as an escape sequence to make # as a part of your prompt and to not use it for commenting anymore.

Few examples for above:

• Give me an example of bubble sort in python # everything written here will be considered as a comment now.

• Explain what this part of the code do: \#include<stdio.h>

  • In the example above \# can be used as an escape sequence to include # as a part of your prompt.

• #This will be considered as a comment as it contains # at the start of the line itself.

Using Macro

Use {{%input%}} macro in the prompt file to refer to the contents of the file provided via -f option.

Example: To check if a file contains JS code or not, you can create a prompt file checkifjscode.txt with following prompt:

Indexing involves breaking down a source code file into smaller chunks and converting these chunks into that can be stored in a . Bito indexes your entire codebase locally (on your machine) to understand it and provide answers tailored to your code.

How Bito Indexes Your Code

In the steps below, we'll show you how Bito indexes your code, ensuring that each query you have is met with precise and contextually relevant information. From breaking down code into digestible chunks to leveraging advanced AI models for nuanced understanding, Bito transforms the daunting task of code analysis into a seamless and efficient experience.

Here's how the magic happens:

Step 1: Chunk Breakdown

Dividing Code into Pieces

Bito starts by breaking down your source code files into smaller sections, known as 'chunks'. It’s like cutting up a long text into paragraphs to make it more manageable. Each chunk represents a piece of your code that can be individually indexed and analyzed.

Step 2: Indexing Each Chunk

Creating a Searchable Reference

After breaking down the file, each chunk is indexed, similar to creating a catalog entry. This step is crucial as it allows for the efficient location of the code segment later on.

Step 3: Generating Embeddings

Translating Code into Numeric Vectors

For every chunk, Bito generates a numeric vector or . This process, which can be done using OpenAI or alternative open-source embedding models, translates the code into a mathematical representation. The idea is to create a form that can be easily compared and matched with other code chunks.

Step 4: Storing the Vectors

Saving the Essential Data

These embeddings are then stored in an index file on your machine. This index file is like a detailed directory, listing the file name, the location of the chunk within the file (start and end), and the embedding vector for each piece of code.

Step 5: Query Embedding

Understanding Your Questions

When you ask a question in Bito's chatbox, the AI checks whether it has some specific keywords like "my code", "my project", etc. If so, Bito generates a numeric vector for your query, mirroring the process used for code chunks.

Step 6: Finding the Nearest Neighbor

Matching Your Query with Code

Using the query's vector, Bito searches the index to find the code chunk with the closest matching embedding. This step identifies the relevant sections of your codebase that can answer your question.

Step 7: Contextualization

Building a Bigger Picture

Identifying chunks is just part of the process. Bito ensures that these chunks make sense in the broader context of your code. If necessary, it expands the search to include complete functions or related code segments, creating a fuller, more accurate context.

Step 8: Leveraging Language Models

Consulting the AI Experts

With the context in hand, Bito consults with language models – either basic (GPT-4o mini and similar models) or advanced (GPT-4o, Claude Sonnet 3.5, and best in class AI models) – to interpret the code within the context and provide an accurate response to your query.

Step 9: Session Privacy

Keeping Your Data Local

All the indexing and querying happens on your local machine. The index files are stored in the user’s home folder, for example on Windows the path will be something like C:\Users\Furqan\.bito\localcodesearch folder. It ensures that your code and session history remain private and secure.

Step 10: Safeguarding Data

Ensuring Confidentiality

Bito is committed to privacy. All LLM accounts it uses are under strict agreements to prevent your data from being used for training, recorded, or logged.

Step 11: Handling Hallucination

Reducing AI Fabrication

Bito is designed to minimize AI 'hallucinations' or fabrications, ensuring the answers you receive are based on your actual code. Although complete elimination of hallucination isn't feasible, as it sometimes aids in constructing beyond seen data, Bito strives to keep it in check, especially when dealing with your local code.

With these steps, Bito provides a robust and privacy-conscious method for indexing and understanding your code, simplifying navigation and enhancing productivity in your development projects.

In Bito, collaboration happens within a Workspace, where team members are assigned roles and access based on their responsibilities. In most cases, every organization would create one Workspace. Anyone can , create a workspace for their team, and invite their coworkers to join the Workspace.

The dashboard introduces a clear, flexible interface for managing user access and feature seats across your team.

Seat management overview

At the top of the Members dashboard, you’ll see a summary of your seat usage and assignment status:

• Seats purchased: Displays the total number of seats your workspace has purchased and the total billing amount.

• Seats assigned: Shows how many of those seats are assigned for:

  • Code Review Agent

  • AI Chat/Wingman

• Seat assignment mode:

  • Auto: In this mode, available seats are automatically assigned to developers when they join the workspace or when they submit their first pull request reviewed by Bito. If all seats are assigned, new seat is purchased and assigned automatically.

    • Note: This mode is useful for dynamic teams where new contributors are added frequently.

  • Manual: In this mode, workspace admins need to manually purchase seats and assign them to developers as needed. Bito will review pull requests only for submitters who have an assigned seat.

    • Note: This mode is ideal for teams that want tighter control over who gets access and when billing occurs.

You can switch between Auto and Manual modes based on your team's seat allocation preferences.

Managing members by feature

Below the seat overview, you'll find three tabs to manage different types of access:

1. Code Review Agent tab

Assign or unassign seats to members specifically for the Code Review Agent feature. Each member listed here can be toggled on or off depending on whether you want to allocate a seat for this feature.

2. AI Chat/Wingman tab

Similar to the Code Review Agent tab, this tab lets you assign or remove access to Bito's AI Chat and Wingman tools. You can also to join the workspace.

3. Admin tab

This tab is dedicated to managing administrative roles within the workspace. Only members with elevated permissions are shown here.

This tab displays a table with the following information:

• Name: Displays the full name and email address of the member.

• Role: A dropdown that allows you to set or update the user’s administrative role:

  • Owner: Full control over the workspace.

  • Admin: Access to most workspace management functions.

  • + Billing contact: (Checkbox) Receives billing-related communications.

  • Billing only: (Button) Limits the member to billing management tasks.

Additional options:

Each admin row has a three-dot menu offering:

• Remove from Admin members: Revoke administrative privileges.

• Remove from workspace: Completely remove the user from the workspace.

Inviting coworkers to the Workspace

You can use Bito in a single-player mode for all the use cases. However, it works best when your coworkers join the Workspace to collaborate with Bito. There are three ways you can invite your coworkers.

Option 1 - Allow your work e-mail domain for the Workspace. This setting is turned on by default, and all users with the same e-mail domain as yours will automatically see the Workspace under "Pending Invitations" when signing up in Bito. You can manage this setting after you create the Workspace through the "Settings" page in your Bito account.

Option 2 - Invite your coworkers via e-mail when you create your Workspace or later from your workspace setting.

Option 3- Share a web link specific to your Workspace via the channel of your choice: e-mail, Slack, or Teams. The link is automatically created and shown when creating a workspace or on the workspace settings page.

Adding Admin members

To add a new admin:

1. Click the “Add members” button at the top of the Admin tab.

2. In the popup:

   • Select an existing user from your workspace, or

   • Invite a new member by entering their email address.

3. Assign the appropriate role and permissions as needed.

Supported Payment Methods

We use as our trusted payment handler to ensure seamless and secure transactions. We offer a variety of convenient payment methods to cater to your preferences.

Below is a list of accepted payment methods:

• Credit and Debit Cards (Visa, Mastercard, American Express, Diners, Discover, JCB, and China Union Pay)

• Google Pay, Apple Pay, Alipay, Cash App Pay

• Bank Accounts in the US and many other countries

Manage (Add or Delete) Payment Methods

Payment methods for Bito are managed securely by Stripe. You can add or delete payment methods if you want.

To add a new payment method, follow these steps:

1. Go to the page.

2. Click on the "Edit payment methods" button.
3. On this page, you will see your currently active plan as well as your existing payments method attached to your account.
4. Click on the "Add payment method" button.

5. A form will open through which you can add any of our supported payment methods mentioned above.
6. Fill in the form and press the "Add" button to add a new payment method.

To delete a payment method, follow these steps:

1. Go to the page.

2. Click on the "Edit payment methods" button.
3. On this page, you will see your currently active plan as well as your existing payments method attached to your account.
4. Click on the three dots button in front of the payment method you want to delete.
5. Now click "Delete" from the popup menu.

6. A warning popup box will open, asking you to confirm whether you really want to delete the payment method.
7. Simply click the "Delete payment method" button on this warning popup to remove this payment method from your account.

8. As you can see in the below screenshot, the "Visa" payment method is removed successfully.

Prompt Engineering is the art and science of crafting inputs (prompts) that guide AI to produce the desired outputs. It's about understanding how to communicate with an AI in a way that leverages its capabilities to the fullest. Think of it as giving directions to a supremely intelligent genie without any misunderstandings.

Why is it Important?

Generative AI, like OpenAI’s GPT models, are revolutionizing industries from content creation to coding. But their utility hinges on the quality of the prompts they receive. A well-engineered prompt can yield rich, accurate, and nuanced responses, while a poor one can lead to irrelevant or even nonsensical answers.

The Anatomy of a Good Prompt

Clarity and Specificity

AI models are literal. If you ask for an article, you'll get an article. If you ask for a poem about dogs in space, you’ll get exactly that. The specificity of your request can significantly alter the output.

Example:

• Vague Prompt: Write about health.

• Engineered Prompt: Write a comprehensive guide on adopting a Mediterranean diet for improving heart health, tailored for beginners.

Contextual Information

Providing context helps the AI understand the nuance of the request. This could include tone, purpose, or background information.

Example:

• Without Context: Explain quantum computing.

• With Context: Explain quantum computing in simple terms for a blog aimed at high school students interested in physics.

Closed vs. Open Prompts

Closed prompts lead to specific answers, while open prompts allow for more creativity. Depending on your goal, you may need one over the other.

Example:

• Closed Prompt: What is the capital of France?

• Open Prompt: Describe a day in the life of a Parisian.

The Practice of Prompt Engineering

Prompt engineering is not a "get it right the first time" kind of task. It involves iterating prompts based on the responses received. Tweaking, refining, and even overhauling prompts based on output can lead to more accurate and relevant results.

A significant part of prompt engineering is experimentation. By testing different prompts and studying the outputs, engineers learn the nuances of the AI's language understanding and generation capabilities.

Keywords are the bread and butter of prompt engineering. Identifying the right keywords can steer the AI in the desired direction.

Example:

• Without Keyword Emphasis: Write about the internet.

• With Keyword Emphasis: Write an article focused on the evolution of internet privacy policies.

Advanced Techniques

Chain of Thought Prompts

These prompts mimic a human thought process, providing a step-by-step explanation that leads to an answer or conclusion. This can be especially useful for complex problem-solving.

Example:

• Chain of Thought Prompt: To calculate the gravitational force on an apple on Earth, first, we determine the mass of the apple and the distance from the center of the Earth...

Zero-Shot and Few-Shot Learning

In zero-shot learning, the AI is given a task without previous examples. In few-shot learning, it’s provided with a few examples to guide the response. Both techniques can be leveraged in prompt engineering for better results.

Example:

• Zero-Shot Prompt: What are five innovative ways to use drones in agriculture?

• Few-Shot Prompt: Here are two ways to use drones in agriculture: 1) Crop monitoring, 2) Automated planting. List three more innovative ways.

Ethical Considerations and Limitations

• Bias and Sensitivity: Prompt engineers must be mindful of inherent biases and ethical considerations. This includes avoiding prompts that could lead to harmful outputs or perpetuate stereotypes.

• Realistic Expectations: LLMs and Generative AI are powerful but not omnipotent. Understanding their limitations is crucial in setting realistic expectations for what prompt engineering can achieve.

• Data Privacy and Security: As prompts often contain information that may be sensitive, engineers must consider data privacy and security in their designs.

Conclusion

Prompt engineering is more than a technical skill—it’s a new form of linguistic artistry. As we continue to integrate AI into our daily lives, becoming adept at communicating with these systems will become as essential as coding is today.

Whether you’re a writer, a developer, or just an AI enthusiast, mastering the craft of prompt engineering will place you at the forefront of this exciting conversational frontier. So go ahead, start crafting those prompts, and unlock the full potential of your AI companions.