twenty

g was expensive. It needed a well maintained staging environment. Engineers needed to know what to test. Most teams never actually did it. Over the last year, coding agents have gone writing some of my code to almost all my code now. Teams are shipping way more code than they were 6 months ago. Code review tools read the diff, but a lot of reliability bugs aren't in the diff. They're in how your code behaves when Stripe, Redis or the network misbehaves. And e2e tests usually mock those services out and test the happy path. Agents have made this type of testing a lot cheaper. And we will see more of this (kinda like security scanning / testing) How it works A full copy of your app per PR: Postgres, Redis, Kafka, SQS, S3. Working copies of your third-party dependencies: Stripe, Slack, Gmail and more. Traffic goes through our proxy, which lets us inject failures. The agent picks what to test: It reads every PR and writes down invariants that need to hold (for e.g. a customer should never be charged twice). It then injects faults likely to break the invariants. Bugs we've found We ran Opslane on some popular open-source apps and here are some of the bugs we have found: 1/ Twenty: deleting a workspace while Stripe is failing locks everyone out, and billing keeps going. Twenty merged a fix. (https://github.com/twentyhq/twenty/issues/28043) 2/ Dub: a restart in the middle of a payout paid a partner $240 for $120 owed. (https://github.com/dubinc/dub.link/issues/4707) Full list: opslane.com/open-source Opslane is pretty early - we have a couple of early customers. We have found bugs in their system that their other code review tools missed. Would love to get feedback from folks and how they are seeing the reliability of their systems evolve over time with agents.

otherwise. That's what I'm building at opensource.builders[2]: turning OSS repos into a modular cookbook with structured "skills" that point to exact details for reliable remixing and porting. SaaS companies are forever beholden to raising their market cap, even in solved spaces like cart, payment processing, and CRMs. Most businesses run on CRUD apps anyway, and if your core app exposes an API, you can build any customization you need on top of it. People here discounting how valuable it is for a business to have the software that runs their business on a tech stack they understand and something they truly own. [0] https://github.com/twentyhq/twenty [1] https://github.com/medusajs/medusa [2] https://opensource.builders

dollar company while massively driving the costs down for everyone. It's kind of like the Prisoner's Dilemma: If every company keep their software proprietary, they can all make moderate growth/profit. But if one goes open-source, they could attract a large community, drive innovation, and potentially reap long-term profits while reducing the overall market size. [1] https://github.com/twentyhq/twenty

realized what they really needed was production code experience, so I started sending them tickets from my backlog to grow them through code reviews. I also paid them for it. They learned a lot and I got a lot done, which started GitStart. That’s why, in the description above, we say “devs who want to grow”. This is key to what we do—we are not just a body shop or middleman, and we don’t charge by the hour. We provide useful mentorship to junior devs. We want to be a meaningful part of their career path. Our thesis (to use that slightly pretentious word) is that the economics work better this way as well. There is a lot of junior dev talent in these countries whose potential will bever be realized by hourly piecework. What’s needed are longer term relationships and work engagements, over the course of which a junior dev can learn and grow on a large production codebase. Much of this has to do with learning the culture of effective tech teams. On the other side, effective tech teams don’t want hourly piecework either. Clients tell us they love having developers dedicated to their project, becoming more familiar with the code over time. This is the way for value to be maximized on both sides. A number of commercial open source repos already use us, so you can check out some of the PRs created by GitStart here: Cal.com: https://github.com/calcom/cal.com/pulls?q=is%3Apr+author%3Ag... SourceGraph: https://github.com/sourcegraph/sourcegraph/pulls?q=is%3Apr+a... StoryBooks: https://github.com/storybookjs/storybook/pulls?q=is%3Apr+aut... Strapi: https://github.com/strapi/strapi/pulls?q=is%3Aclosed+is%3Apr... Supabase: https://github.com/supabase/supabase/pulls?q=is%3Apr+author%... Twenty: https://github.com/twentyhq/twenty/pulls?q=is%3Apr+author%3A... Our main technical challenge has been securing code sharing. One solution was building GitSlice, which enables creating sub-repos that sync with the upstream repo. When GitStart devs create PRs on the platform, GitSlice syncs them upstream while pulling back CI/CD checks and review comments. This enables our devs to contribute with limited codebase access. To prevent slices from breaking, we verify they run within a docker container, which also enables us to build review environments. Fun fact: we managed to support native iOS and Android codebases by building and running them on appetize.io instead of docker. There have been countless attempts at this space so we would love to hear your feedback on how we approached this problem or your past experiences working with junior devs in this way. We look forward to a good conversation!

n API. Then we retrieve the image and store it into S3. The next time someone asks for the image it is usually served from our CDN cache directly. If not, then it’s pulled from S3. Cloud Hosting: We are hosting a server on favicon.twenty.com. We will be using it to power Twenty CRM, so it will be maintained up and running for our own needs. Feel free to use it by directly by embedding images like this: https://favicon.twenty.com/google.com or https://favicon.twenty.com/google.com/64 [1] https://github.com/twentyhq/twenty