CRM can also be "git-ified": Twenty, with over 50,000 stars, allows developers to directly modify the sales system using Git.

CRM can also be "git-ified": Twenty, with over 50,000 stars, allows developers to directly modify the sales system using Git.

3 weeks ago
duguying
19 views
Source: GitHub

I have written 20 CRM objects, fields, and views in TypeScript code and published them to my workspace using `npx twenty app:publish`. The project claims to be the first open-source CRM and currently has 112 stars.

Related tags

#GitHub#Trending#Twenty#CRM#开源

CRM Can Be Git-Ized: Twenty, with 5.9 Million Stars, Enables Code Agents to Directly Modify Sales Systems

This article is based on the README of the GitHub project twentyhq/twenty.

Summary: Twenty converts CRM objects, fields, and views into TypeScript code, publishing them to a workspace using `npx twenty app:publish`. The project claims to be "#1 Open Source CRM," with 59,209 stars and 112 new stars added today.


CRMs are often the most contradictory type of software in business: they're sold based on "standard processes," but each company uses them differently. The cost of modifying or migrating a CRM is high, so most teams end up moving data between Excel and their CRM systems.

Twenty's solution is to treat the CRM as code. Its positioning is "Salesforce's open-source alternative, designed for AI," targeting technical teams – providing them with building blocks to create a CRM that can quickly adapt to changing business needs and be built, shipped, and versioned like other technology stacks.

As of today, the project has 59,209 stars on GitHub, with 112 new stars added daily.

Objects, Fields, and Views Are Code

Get started with the CLI:

npx create-twenty-app my-app

Then, declare objects in the project. The README provides an example of a `deal` object:

import { defineObject, FieldType } from 'twenty-sdk/define';

export default defineObject({
  nameSingular: 'deal',
  namePlural: 'deals',
  labelSingular: 'Deal',
  labelPlural: 'Deals',
  fields: [
    { name: 'name', label: 'Name', type: FieldType.TEXT },
    { name: 'amount', label: 'Amount', type: FieldType.CURRENCY },
    { name: 'closeDate', label: 'Close Date', type: FieldType.DATE_TIME },
  ],
});

Publish to the workspace:

npx twenty app:publish --private

This code reveals more than it appears. First, the CRM data model is declarative – adding a "contract amount" field or changing a stage name uses code and publishing, rather than navigating through multiple menus in the backend. Second, the field types are strongly typed (e.g., `FieldType.CURRENCY`, `FieldType.DATE_TIME`), meaning that amounts and dates have semantic meaning at the data level, which can be used for reporting and automation without guessing. Third, because the model is in code, it's reviewable, roll-backable, and collaborative.

For teams already familiar with Git workflows, this paradigm requires little learning; for CRM administrators who have been stuck with "configuration-lock," this is a paradigm shift.

Interfaces for Code Agents

The README includes a section that's often overlooked but crucial: if you're using a code agent, you can install the official Twenty app skills.

npx skills add https://github.com/twentyhq/twenty/tree/agent-skills --list

These skills can be used in Claude Code, Codex, Cursor, Pi, and any harness that supports the `` CLI. The README also explains the purpose of other skill families in the repository (see ), and specifies that the `` branch is automatically generated when the `` branch is successfully published for the first time.

In other words, Twenty isn't just a system that can be modified by an agent; it also provides a way to make sure the agent modifies it correctly. This is rare in the CRM category – most enterprise software still treats AI as simply providing a built-in chat box.

Deployment Options

  • Cloud: Register on twenty.com, start a workspace in minutes, and don't worry about infrastructure; it will always be the latest version. This is the fastest option.
  • Self-hosted: Run using Docker Compose on your own infrastructure, with complete instructions in the official documentation.
  • Local development: For those who want to contribute or deeply customize, you can set up the frontend and backend locally according to the local build guide.

The README also indicates that the Roadmap is publicly available on GitHub Projects, and the design drafts are open on Figma, while the community is on Discord.

Should You Try It?

It's worth paying attention to these three groups: companies with highly non-standard sales processes who don't want to build a CRM from scratch; teams that want to bring CRM data and other internal systems together using the same code standards; and architects who are evaluating whether AI can directly operate on business systems – Twenty's code-based model makes it possible to audit how an agent modifies the system, rather than relying on a model blindly operating in a UI.

However, it's important to remember that this also means transferring responsibility: if you make mistakes in designing the fields or mess up the migration, it's your own submission. This replaces the "wait for the vendor to fix it" approach with a faster, more hands-on process.

Project address: https://github.com/twentyhq/twenty

🔁 Repetition Rate: Low — No prior reports found for Twenty on this topic, making a normal publication possible.

More News

Want to see more quality content?

Browse all news