SuperAPI AI Directory
Partner with us中文AI newsFavorites
All toolsAI codingclippy

clippy

Clippinator (formerly Clippy) is a GPT-4-based AI programming assistant that collaborates through multiple agents and can plan, write, debug, and test code. It includes the Taskmaster main agent and sub-agents such as Architect, Writer, Frontender, Editor, QA, and Devops, each with different prompts and tools. It supports file reading and writing, terminal commands, background processes, Selenium browser automation, and other capabilities. To use it, you need to install dependencies such as Poetry, ctags, and pylint, configure the OpenAI API key (optionally SerpAPI), and run it from the command line with the project path specified. It can work autonomously, and is more efficient with human feedback. It is suitable for assisting in the development of medium-to-large projects, but note that API costs are relatively high, and errors may occur, so human supervision is recommended.

Open website

About this tool

Clippinator (formerly Clippy) is an AI programming assistant designed to develop code together with users, and can autonomously plan, write, debug, and test projects. It is composed of multiple GPT-4-based agents that collaborate to help users complete development tasks. This tool was created by Lev Chizhov and Timofey Fedoseev, with contributions from Sergei Bogdanov as well.

Purpose

Clippinator's main purpose is to assist with code development. It can complete some projects autonomously, and in more complex tasks, it can be even more effective when users review its work and provide feedback. If the project is simple, users only need to provide high-level guidance, such as "write a link-shortening web service"; if the project is complex, user involvement will be higher, but Clippinator will still handle most of the work.

Main Capabilities

The core of Clippinator is a main agent called Taskmaster, which is responsible for overall development. It can call tools and delegate tasks to sub-agents. To support long-running operation, history is summarized.

Taskmaster first asks the user questions to understand the project, then has the Architect plan the project structure, and then delegates sub-agents to write, debug, and test the project. All agents can access the planned project architecture, the current project structure, linter errors, and memory. The tools used by the agents include writing files, using bash (including running background commands), using Selenium for browser automation, and more.

The specific agents include: Architect, Writer, Frontender, Editor, QA, and Devops. They have different prompts and tools.

The architecture is text written by the Architect, containing a list of files and summaries of their contents (in the form of comments), and important lines (such as classes and functions). The architecture is available to all agents, and implementing the architecture is the agents' goal in the early stages.

A variety of tools have been implemented or introduced from Langchain:

  • File tools: WriteFile, ReadFile, etc. (some are currently unused).
  • Terminal tools: RunBash, Python, BashBackground (allows starting and managing background processes, such as launching a server).
  • Selenium: browser automation for testing, allowing viewing pages, getting console logs, clicking, typing, and executing Selenium Code.
  • HttpGet, GetPage: simpler tools for fetching pages.
  • DeclareArchitecture, SetCI, Remember: allow agents to set up the environment, write architecture, and remember information.

Project structure, Linting, CI, memory: the project structure is provided to all agents; it is a list of files obtained by ctags and their important lines. Linter output is provided next to the project structure, helping to understand the current problem. Linter output is also provided after using WriteFile. The Architect can use the SetCI tool to configure the linter command. All agents can use the Remember tool to add information to memory, and the memory is available to all agents.

Usage

  1. Install Poetry.
  2. Clone this repository.
  3. Add the OpenAI API key to the .env file: OPENAI_API_KEY=.... Optional: add a SerpAPI key to allow the model to use search: SERPAPI_API_KEY=.
  4. Install ctags.
  5. For pylint, install it and pylint-venv.
  6. Install dependencies: poetry install.
  7. Run: poetry run clippinator --help. To run on a project, use: poetry run clippinator PROJECT_PATH.

You can stop it, and then it will continue from the last saved state. Use ^C to provide feedback to the main agent.

Note: if you press ^C during the execution of a sub-agent, the sub-agent will be aborted. The only exception is the Architect: you can press ^C after it uses the DeclareArchitecture tool to ask it to make changes.

After the Architect runs, if you choose y in the prompt, you can also manually edit the project architecture. If you enter m or menu, you can also edit the project architecture, goals, and other content.

Applicable scenarios and limitations

Clippinator is suitable for developing code, and can work both autonomously and collaboratively with the user. It is based on GPT-4 and runs for a long time, so the OpenAI API cost is quite high. It is not perfect and can often make mistakes, but when combined with a human it is very powerful. For simple projects, the user only needs to provide high-level guidance; complex projects require more involvement,but Clippinator will still do most of the work.

Related tools

Browse category