DEV Community: gitcommitshow

[Boost]

gitcommitshow — Tue, 24 Mar 2026 15:15:42 +0000

gitcommitshow

Mar 24

GitHub action to make your website analytics fail-proof and free from vendor lock-in

#ai #githubactions #analytics #javascript

Comments

4 min read

GitHub action to make your website analytics fail-proof and free from vendor lock-in

gitcommitshow — Tue, 24 Mar 2026 15:06:41 +0000

The Problem - Analytics breaks silently

Website analytics issues do not surface as incidents the way other bugs do. They slip through the crack silently. You get to know about them only when you are looking at the revenue analytics dashboard and the metrics do not match your accounting books, your gut finally says, probably I should check the analytics instrumentation code for issues.

Had this check existed on every PR that changed the analytics instrumentation code, none of this would have reached the dashboard. And you wouldn’t have made bad business decisions on faulty analytics data.

Let's get it done in the next 15 mins!

First, make your analytics free from vendor lock-in using RudderStack SDK

Currently you might have one or more analytics SDKs (Google Analytics, Amplitude, Google Ads, etc.) in your website. This slows down your website. And because they are tightly integrated with your app as code, if you want to switch to another vendor, you'll have to import their SDK and make the changes in the code. A long error-prone process.

In the next 5 mins, you'll get rid of all of them without breaking the analytics.

To do that, you need one SDK to rule them all. Provided by event streaming tools such as Segment or its self-hosted alternative RudderStack.

After setting it up, you will be able to collect events from your websites (source) and send it to any analytics/marketing service of your choice (destination).

With that in place, if you ever need to switch to a different analytics service, it will be a quick dashboard settings change, not a code change in your website.

Here’s how to replace all your analytics and marketing tool SDKs with one RudderStack SDK

Step 1: Create your dashboard to control your data sources/destinations settings. This dashboard controls only these settings. The actual customer event data will not flow through this service. You will either self-host the event streaming server to process customer event data i.e. the data plane or use a cloud-hosted data plane to quickly get started. Source code - https://github.com/rudderlabs/rudder-server

Step 2: Replace all your existing analytics SDKs with one RudderStack SDK
tl;dr: add these 5 lines of code in your website

// Step 1: Install the SDK - `npm i @rudderstack/analytics-js`
// Step 2: Initalize the SDK
import { RudderAnalytics } from '@rudderstack/analytics-js';
const rudderAnalytics = new RudderAnalytics();
rudderAnalytics.load(process.env.WRITE_KEY, process.env.DATA_PLANE_URL, {});
// Q: How to generate your WRITE_KEY and DATA_PLANE_URL?
// A: Create a new JavaScript source at https://app.rudderstack.com
export { rudderAnalytics };
// Step 3: Call event tracking methods such as `page`, `track`, `identify`, etc. as needed
rudderAnalytics.page();
// NOTICE: This code works only if you have set up your browser-side code to use `npm` modules. Follow the quickstart guide otherwise - https://www.rudderstack.com/docs/sources/event-streams/sdks/rudderstack-javascript-sdk/quickstart/

You made the change in your website code. Raised a PR, not merged yet.
When you visit your test server link to your website. In your RudderStack source live events dashboard, you should now see the events flowing.

But events are not flowing to your previous destinations yet. So let’s fix that.

Step 3: Add your original analytics/marketing services as destinations in your RudderStack dashboard to restore your old analytics services. These services are supported as the destinations out of the box, others can be supported either via webhook or by building your own custom integration - https://github.com/rudderlabs/rudder-transformer/blob/develop/CONTRIBUTING.md#building-your-first-custom-rudderstack-source-integration

Now, when you visit your test server again, you should be able to see these events in your analytics services as they were flowing earlier. The destination live events will show you everything you need at this point.
With the analytics instrumentation done, half the battle is won.

You are in control now, free from the analytics vendor lock-in

You can merge at this step, but wait!
Before you merge the PR, let’s do something that will ensure that you do not accidentally break your analytics in future.

We will add a GitHub Action to review your PRs for analytics instrumentation and data quality issues.

Second, make your analytics fail-proof using AI-powered GitHub workflow

Let’s use this GitHub action - https://github.com/rudderlabs/rudder-ai-reviewer

With this, you will never break your analytics instrumentation and your data quality issues will never end up in production.

Create .github/workflows/rudder-ai-reviewer.yml in your repo:

name: Rudder AI Reviewer
on:
  pull_request:
    types: [opened, synchronize]

permissions:
  contents: read        # Required to checkout the repository
  pull-requests: write  # Required to post review comments

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1

      - name: Rudder AI Reviewer
        uses: rudderlabs/rudder-ai-reviewer@v1
        with:
          source-id: ${{ secrets.RUDDERSTACK_SOURCE_ID }}
          service-access-token: ${{ secrets.RUDDERSTACK_SERVICE_ACCESS_TOKEN }}

Commit, push, open a PR that touches any instrumentation code. The reviewer runs automatically. The action will detect the RudderStack SDK and the instrumentation changes automatically, review using AI, suggest fixes as inline review comments.

Now, you can go ahead and merge the PR if Rudder AI Reviewer does not give you any warning.

In future, you'll automatically receive reviews on PRs that impacts the analytics instrumentation, data quality, and privacy compliances. You can further improve this workflow by creating a tracking plan in your RudderStack dashboard.

Go ahead and explore the tools I mentioned here for more details

Mastering Code Review skills using AI tools

gitcommitshow — Sun, 11 Feb 2024 18:30:00 +0000

The skill of conducting effective code reviews is an important skill for developers. Code reviews ensure high-quality code, facilitate knowledge sharing, and foster a collaborative team environment. Despite its importance, many tech leads and developers find themselves either spending an excessive amount of time on code reviews or struggling to provide constructive feedback to pull request (PR) authors.

Conversely, some colleagues seem to navigate code reviews with ease, showcasing that code review is indeed a skill that can be honed and improved.

But the question remains: How does one improve their code review skills? Is it beneficial to seek feedback from a coworker, compare your code review techniques with those of your peers, or is there an alternative strategy to enhance this critical skill?

Given the specificity of PRs to individual projects, generic feedback often falls short of being genuinely helpful. While coworkers can offer valuable insights, their availability to provide immediate feedback—when the context of the PR code changes is still fresh in your mind—can be limited.

The solution is “Self-Assessment”. Assess your Code Review skills and then improve your weaknesses.

How to Assess Code Review Skills and Improve

Embarking on a journey to refine your code review skills, self-assessment emerges as the most effective strategy. This approach not only fosters a deeper understanding of code review practices but also encourages a mindset of continuous improvement. Here's a detailed plan to self-assess and enhance your code review capabilities:

1. Set a Time Limit for Reviewing New PRs

Begin by allocating a specific time frame, such as 15 minutes, to review new PRs. This constraint encourages efficiency and helps you focus on identifying the most critical aspects of the code without getting bogged down in minutiae.

2. Utilize Automated AI Tools

After completing your review, employ automated AI-based code review tools such as CodeRabbit. These tools can quickly analyze code for common issues, style inconsistencies, and potential bugs, providing an immediate second opinion on the PR.

3. Compare and Reflect

Evaluate the feedback from the AI tools against your own review. Did you overlook anything obvious? Did you suggest any unnecessary optimizations? Reflecting on these comparisons helps you understand your review tendencies and biases, enabling you to adjust your approach accordingly.

4. Repeat and Learn

Make this self-assessment process a regular practice for new PRs. Each iteration offers new learning opportunities, gradually enhancing your ability to conduct thorough and effective code reviews.

5. Seek Feedback from Coworkers

In addition to self-assessment, actively seek out code reviews from your coworkers on your own contributions. This practice not only improves your code but also provides insight into different review styles and perspectives, enriching your understanding of effective code review practices.

Why Self-Assessment Works

Self-assessment in code review serves multiple purposes. It not only accelerates your learning curve by providing immediate feedback but also cultivates a culture of self-improvement and accountability. By comparing your reviews with automated feedback and reflecting on the differences, you gain insights into your review process that would be difficult to achieve through external feedback alone.

The Benefits of Mastering Code Review

Mastering the art of code review carries numerous benefits for both individual developers and their teams:

Enhanced Code Quality: Effective code reviews catch issues early, reducing bugs and improving the overall quality of the codebase.
Knowledge Sharing: Code reviews serve as a platform for sharing knowledge and best practices, helping team members learn from each other and grow their skills.
Faster Development Cycles: By identifying and addressing issues early in the development process, teams can reduce the time spent on debugging and rework, leading to faster development cycles.
Improved Team Collaboration: Regular and constructive code reviews build trust among team members, foster a culture of open communication, and encourage collaborative problem-solving.

Conclusion

Improving your code review skills is a journey that requires patience, practice, and a proactive approach to learning. By embracing self-assessment, utilizing tools at your disposal, and engaging with your team, you can transform code review from a daunting task into an opportunity for growth and collaboration. Remember, the goal of code review is not just to find faults but to collectively ensure the development of high-quality, maintainable, and efficient code. As you refine your code review skills, you'll find yourself not only becoming a more effective reviewer but also contributing to the success and resilience of your development team.

Boosting Engineering Efficiency Using AI Code Reviews for Remote Teams

gitcommitshow — Fri, 09 Feb 2024 18:30:00 +0000

Welcome to the future, where morning commutes involve going from bed to home office. The dress code is "business on top, pajamas down below." In this new world of remote work, tech teams worldwide are getting good at video calls and wishing for strong Wi-Fi like strong coffee. But here's the question: How do we maintain engineering efficiency when Joe from frontend is in Mexico, and DevOps Dave just started his day in Dublin? This setup presents a unique challenge: ensuring that code reviews, which are essential for code quality, are consistent, timely, and efficient. Have you ever missed a code review because it was late at night? We've all been there. Are you waiting for days to get feedback because your reviewer is in a different time zone? Oh, the frustration! Introducing the helpful algorithm: AI-driven code reviews. They're like a reliable friend who never sleeps (because they're code) and knows all the coding rules. This article explores how these intelligent bots fill the gaps in our fast-paced, sometimes slow, new world.

Direct Correlation: Remote Engineering Challenges & AI Solutions

Remember the good old days when you could easily ask a quick question to a colleague by just going to their desk? Those days are gone, just like floppy disks and dial-up internet. Nowadays, with remote work, we have traded cubicles for couches and water cooler chats for solo trips to the fridge. Let's address the three significant challenges of remote engineering and explore how AI's modern technology can provide a solution.

Communication Gaps: We've all sent that "quick query" across the ocean and received a response when the moon's high in our sky. Time zones, while fantastic for the travel and holiday industry, can be the bane of a remote engineer's existence. The lag between question and answer and the lack of in-person interaction can make collaborating feel like you're screaming into a digital void.

AI Solution: AI doesn't need sleep (lucky them). They're the 24/7 store of the coding world, always open and ready to assist. Offering real-time feedback, irrespective of whether it's midday in Mumbai or twilight in Toronto, AI ensures that time zones remain a challenge only for your travel plans.

Delayed Reviews & Feedback Loops: Here's a familiar scenario: You push code, sit back, and wait. And wait. And wait some more. Your code is in the ether, waiting for a review that's as elusive as a unicorn. The elongated feedback loops in remote settings can sometimes feel like a seemingly endless game of ping pong, where the ball... disappears.

AI Solution: Fancy a game-changer? AI provides immediate feedback. With algorithms working at the speed of computers, the waiting game is dramatically reduced. You push, AI reviews, and voila! Feedback's ready, hotter than a freshly brewed espresso.

Code Consistency & Quality: Have you ever noticed how everyone's homemade bread looks and tastes slightly different? The same goes for code written by engineers scattered across various locales. Influenced by unique experiences and environments, each individual brings slight variances in coding style and approach.

AI Solution: Call AI the master baker, consistently churning out the perfect loaf every time. AI-driven code review tools maintain a unified standard, ensuring that whether it's Peter in Paris or Lila in Lagos, the quality and consistency of code remain top-notch.

Real-World Applications & Pitfalls

In a world where data is king, we enjoy hearing success stories (especially when they include pie charts!). However, there are challenges to overcome when it comes to incorporating AI code reviews in a remote environment. Let's explore the real-life stories of AI experts and the significant obstacles they have overcome.

Common Pitfalls & Solutions

Over-reliance on AI: Just as one wouldn't ask a Roomba to do a deep spring cleaning, leaning too much on AI for code reviews can miss out on the nuanced human touch. Solution: Tech Titans Inc. struck a balance by using AI for preliminary checks and human eyes for final reviews, ensuring that the code was technically sound and made logical sense in the grander scheme.

Resistance to Change: Implementing new tools often meets resistance, especially if developers feel their expertise is being questioned. Startup Sensations Ltd. faced a mini rebellion of sorts. Solution: They organized workshops emphasizing AI as a tool to aid, not replace. Showcasing its strengths and limitations bridged the trust gap, smoothing the integration.

Misunderstanding AI Feedback: Sometimes, AI can flag something as an error, even if it's a deliberate choice by the coder. This can lead to confusion and wasted effort trying to "fix" what isn't broken. Solution: Both companies implemented clear guidelines on understanding and acting upon AI feedback, ensuring developers knew when to consider and contest.

Actionable Takeaways

Navigating the intricate maze of code reviewing can be daunting. But fret not! There are some practical steps and considerations to help steer the ship. And speaking of guiding lights, let's first mention a noteworthy tool that's caught the industry's attention.

CodeRabbit – An AI Code Reviewer

Heard of CodeRabbit? It's this nifty AI tool that's gaining traction. Without all the bells and whistles – it simply reviews your code once pull requests are made. It's a straightforward, no-fuss tool designed to streamline the review process, especially for remote teams.

Steps for Effective Integration and Adoption

Orientation: It's crucial to acquaint your team with any new tool. With something like CodeRabbit, a simple hands-on session or tutorial might suffice.
Pilot Testing: Test the waters first. Let's start with one project or a subset of your team to gauge the tool's efficiency and user-friendliness.
Constructive Feedback: Encourage an open line of communication. Ensure your team provides feedback about the tool's strengths and areas needing tweaks.

Balancing AI Assistance with Human Touch

No matter how advanced our tools get, there's an underlying essence of human insight that can't be entirely replicated. To ensure the balance:

Sequential Reviews: Let AI, like CodeRabbit, serve as the preliminary filter. The team should do subsequent, deeper reviews to capture nuances.
Regular Updates: Keep the AI tool informed. Feedback from human reviewers refines its algorithm, making it more intuitive with time.
Encourage Team Discussions: After automated reviews, foster team discussions. This ensures the code isn't just machine-compliant but also logically sound and efficient from a human perspective.

Conclusion

Ah, the outcome! We've ventured deep into the rabbit hole (no pun intended with CodeRabbit) of AI's transformative role in remote engineering. From the highs of streamlined code reviews to the essential human-AI harmony, it's evident that AI doesn't just knock on the doors of modern engineering—it's barging in, holding a battering ram of innovation.

Remember when remote work was a cute little option, often tucked away in the "benefits" section of a job posting? Well, it's not just mainstream now; it's the modus operandi for countless teams globally. As this mode of work continues to snowball, the technological advancements, especially ones like AI-driven code reviewers, aren't merely luxury add-ons. They are becoming vital cogs in the well-oiled machine that a remote engineering team aspires to be.

As we stand on the brink of yet more seismic shifts in the way we work and collaborate, it's exhilarating to think of the untapped potential of tools and technologies still on the horizon. The canvas of remote work is vast, and we've only just started splashing it with color. Here's to a brighter, more innovative, and yes, more automated future, but always with a sprinkle of irreplaceable human magic.

Cheers to the codes that bind us, both human and binary.

FluxNinja Aperture v1.0 - Managed rate-limiting service, batteries included

gitcommitshow — Thu, 08 Feb 2024 05:50:09 +0000

The FluxNinja team is excited to launch “rate-limiting as a service” for developers. This is a start of a new category of essential developer tools to serve the needs of the AI-first world, which relies heavily on effective and fair usage of programmable web resources.

Try out FluxNinja Aperture for rate limiting. Join our community on Discord, appreciate your feedback.

FluxNinja is leading this new category of “managed rate-limiting service” with the first of its kind, reliable, and battle-tested product. After its first release in 2022, FluxNinja has gone through multiple iterations based on the
feedback from the open source community and paid customers. We are excited to bring the stable version 1.0 of the service to the public.

The world needs a managed rate-limiting service

Whether you are self-hosting a service or using a managed-service, balancing the cost and performance remains a challenge. When hosting on your own, you are responsible for scaling to keep up with demand while keeping costs under control. When using a managed service, you have to comply with their request quotas while keeping usage and costs under control.

This is especially true for applications that use Large Language Models (LLMs). If using cloud-based LLMs, you have to comply with their rate-limits. If using self-hosted LLMs, you have to manage the infrastructure and ensure fair usage. And given the high cost of LLMs, and the shortage of resources such as GPUs, it is crucial to ensure fair usage and cost-efficiency.

To ensure fair usage and deliver a good user experience while being profitable, developers need to code and manage rate limiting and caching infrastructure. It requires significant engineering efforts and expertise.

FluxNinja Aperture solves this challenge of building and managing production-grade rate-limiting by providing a managed-rate-limiting service to enforce and comply with rate-limits based on various criteria such as:

Limits based on no. of requests per second
Per-user limits based on consumed tokens
Limits based on subscription plans
Limits based on token-bucket algorithm
Limits based on concurrency

FluxNinja utilizes a unique approach by separating rate-limiting infrastructure from the core application, which developers don’t need to code or manage anymore. They only need to integrate Aperture SDK, and then rate limiting policies can be updated via UI or API.

We aim to bring production-grade rate-limiting to every app

Overview of FluxNinja Aperture

With FluxNinja Aperture, application developers can enforce rate-limits on the usage of their services or comply with rate-limits of various external services. This ensures reliability of your services, fair usage and cost control.

FluxNinja Aperture provides a managed rate-limiting service that handles the complexities behind the scenes, requiring only simple SDK integration in your application.

These are the key features of FluxNinja Aperture rate-limiting service:

Rate & Concurrency Limiting

Optimize cost and ensure fair access by implementing fine-grained rate-limits. Regulate the use of expensive pay-as-you-go APIs such as OpenAI and reduce the load on self-hosted models such as Mistral.

Caching

Cache LLM results and reuse them for similar requests to reduce cost and boost performance.

Request Prioritization

Manage utilization of constrained LLM resources at the level of each request by prioritizing paid over free tier users and interactive over background queries. Ensure fair access across users during peak usage hours.

Workload observability

Get unprecedented visibility into your workloads with detailed traffic analytics on request rates, tokens, and latencies sliced by features, users, request types, and any other arbitrary business attribute.

For more info, check out FluxNinja Aperture Docs

Challenges with traditional rate-limiting solutions

Traditional approaches to rate-limiting, typically involving custom-built solutions with in-memory data stores such as Redis, have presented significant
challenges.

Managing the codebase and infrastructure for rate-limiting demands regular attention from engineers and DevOps, incurring significant costs.

API gateways work for limited use cases; they lack the context-specific understanding required for business aware rate-limiting (e.g., per-user limits or subscription-based restrictions).

There is currently no ready-made solution where a distributed application needs to comply with rate-limits of an external service.

These limitations highlight the need for a more efficient, context-aware, and easy-to-manage rate-limiting solution suitable for modern application demands.

How FluxNinja Aperture solves these gaps

Aperture separates rate-limiting infrastructure from the application code. You can self-host it using the Aperture open source package or use the hosted solution - Aperture Cloud. To manage rate-limits, you only need to integrate Aperture SDKs in your programming language.

Benefits compared to custom Redis-based or makeshift solutions:

No need to code and manage complex rate-limiting algorithms and infrastructure
Rate-limit policies and algorithms are updated centrally via UI or API rather than application code changes
Real-time analytics dashboards to monitor and tune configurations

With FluxNinja Aperture, the heavy lifting is offloaded, allowing you to focus
on business logic while still retaining control over policies.

FluxNinja Aperture also integrates with existing service mesh and API gateways, giving a quick upgrade to your existing rate-limiting infrastructure.

You can easily configure these constraints using Aperture policies. And then wrap your code block with Aperture SDK calls where you use these external or internal services. Using the Aperture Cloud UI, you’ll be able to monitor the
workload and effectiveness of rate-limit policies.

Check out this example to get started with enforcing or complying with rate-limits using FluxNinja Aperture.

Customer case study

CodeRabbit is a leading AI Code Review tool and they are an early adopter of FluxNinja Aperture. The CodeRabbit app consumes several LLM APIs. They offer
code review services through various subscription tiers to their users, including a free trial and an unlimited plan for open source projects. The high cost of LLM services and huge demand for their own service made it a challenge
to offer an accessible pricing for their users while being cost-efficient. CodeRabbit uses FluxNinja Aperture to prioritize, cache, and rate-limit requests
based on user tier preference and time criticality. FluxNinja helps them deliver a great user experience while being cost-efficient.

Conclusion (tl;dr;)

Rate limiting is crucial for web services, especially for those using Generative AI, to ensure fair usage, cost-efficiency, and a better user experience. Traditional methods often require heavy engineering work and struggle to address
more nuanced needs such as user-specific or token-based limits.

FluxNinja Aperture solves this by providing an SDK-driven managed-rate-limiting service, making it easy to enforce your own rate-limits and comply with rate limits of the services you use. With FluxNinja Aperture, teams do not need to
invest their engineering bandwidth in building and maintaining complex rate limiting infrastructure. You can self-host FluxNinja Aperture on your premise or
use the cloud offering at a nominal cost. It is as easy as integrating the FluxNinja SDK in your Node.js, Python, Golang, or Java backend apps.

FluxNinja team is excited to unveil this tool publicly for developers. Join us in this journey of bringing production-grade rate-limiting to every app.

Visit FluxNinja Aperture docs to get started with enforcing or complying with rate limits now.

Prototype to Production Roadmap for Generative AI-based Products

gitcommitshow — Tue, 06 Feb 2024 18:30:00 +0000

As we enter 2024, Generative AI-based applications are poised to become
mainstream

Given Generative AI’s limitations at the start of 2023, the world was skeptical whether Generative AI would deliver tangible value to the businesses and to the customers. With the current state of Generative AI services, it seems totally possible. Many of us have by now built some prototypes of Generative AI-based apps that are effectively solving specific business problems and delivering concrete value to a small set of users.

This was possible due to continuous improvements in Generative AI services from GPT-3.5 to GPT-4-Turbo, from LlaMa to Mistral, and many more incremental as well as disruptive developments. We were able to confidently use Generative AI services to deliver value consistently, and the dream of building useful Generative AI-based apps is not a dream anymore but a reality.

In 2024, we will see massive adoption of such Generative AI-based products

After building a prototype, the next challenge one needs to solve is how to ship those prototypes to the hands of millions of such users reliably in production. And that is not yet done by many but has been proven to be possible.

A prime example of this is CodeRabbit, a leading AI Code Review tool that utilizes GPT for automating PR reviews.

CodeRabbit was launched in Sep 2023, and has already scaled to 1 million+ monthly requests served using GPT APIs. Its 100% success in delivering those requests and a satisfied customer base of 57000+ code repositories demonstrates the practical viability of Generative AI in building scalable businesses that deliver concrete value to users.

Transitioning from a prototype to a production stage is not as easy though, it involves several challenges. These include managing operational costs, preventing service abuse, handling AI service outages, and maintaining a robust user experience while scaling to accommodate millions of users. CodeRabbit's journey exemplifies that with the right approach, these challenges can be overcome to achieve success in production.

This article aims to guide you through the process of transitioning your Generative AI-based application from prototype to production. We will discuss strategies to address the common hurdles such as cost efficiency, reliability, scalability, and user experience optimization. The goal of this article is to provide a clear, technical roadmap for scaling your Generative AI application effectively.

Understanding foundational Generative AI models and services

There are multiple foundational Generative AI models and services encompassing a wide range of technologies that have the capability to generate new content, solve problems, or process information in innovative ways. These services can be
utilized to enable more specific use cases.

These Generative AI models/services can be broadly categorized as follows:

Text generation and processing

Leading models to generate or process text are - GPT-4, Mistral, Claude, LlaMa, and so on. They can generate human-like text, answer questions, summarize content, translate languages, and more. Most of these models are also available as API service, so it is easier to implement those without worrying about the model deployment. But you have to do all other things related to productizing the solutions built on top of these services.

Example use cases:

Automated Writing Assistants for Grammar checking, style improvement, and content generation, and so on.(such as Grammarly or ProWritingAid)
Automatically generate draft blog posts and articles
Create conversational dialogue for chatbots and virtual assistants
Generate ideas and creative story premises for writers
Summarize texts and documents for consumers

Image generation

Image Generation models such as MidJourney, Stable Diffusion, DALL-E, Imagen, Imagen Editor etc. can create images and artworks from textual descriptions.

Example use cases:

Generate unique profile pictures and avatars
Create original artwork for digital artists and designers
Produce images for marketing materials and social media posts
Conceptualize product designs through visualizations

Voice generation

There are multiple high-quality Text-to-Speech (TTS) models and services available now that convert text into spoken voice, such as
ElevanLabs, XTTS/Coqui, WaveNet, Amazon Polly, etc.

Music or Sound generation

Some of the popular music or sound generation models/service include MusicGen, AudioGen, AudioCraft, Jukebox, Magenta, WaveNet, etc.

Example use cases:

Compose background music for videos and other multimedia
Create custom ringtones and notification sounds
Produce sound effects for games, VR, and AR experiences
Generate musical ideas and samples for musicians

Video generation

This category is not as mature as other Generative AI categories and we might have to wait a bit more for improvements to see massive amounts of practical use
cases. Presently, some of the popular models/services to generate video from text/image are - RunwayML, CogVideo, Imagen, Make-a-Video, Phenaki, Synthesia, Stable Video, VideoPoet,
and so on.

Example use cases:

Automatically produce training videos for educational purposes
Create visual marketing content to promote brands and offerings
Generate video templates and effects for editing
Conceptualize scene frameworks for filmmakers and creators

General purpose

Reinforcement learning models - can be optimized to complete various sequential decision-making tasks like game playing, autonomous robotics vehicle operations.
Some examples in this category are - NVIDIA DRIVE (self-driving solutions), AlphaZero (chess game playing).

Example use cases:

Play games against humans by mastering gameplay strategy
Control robotic systems to automate business processes
Optimize machine behaviors for complex sequential tasks
Develop product innovations through iterative simulated testing

Future categories

In 2024, we might see some more categories as more foundational models are created that are optimized for a specific task or industry and enabling more use
cases. Some of the new categories we predict to get developed in 2024 will be related to data analysis, predictions, gaming, industrial automation, autonomous
vehicles, healthcare diagnostic, adaptive learning, and explainable AI (XAI).

You or your competitors might have built a prototype based on these foundational models or services already. If not, it is likely that you’ll do that in 2024.
However, how do you move beyond the prototype and make it available in production to real users, and that too at a practical scale which drives significant impact?

Path from prototype to production

Drawing on my personal experience and the insights gained from others, let me share the specific steps to take your Generative AI-based solution from prototype to production. I'll also provide tips for each step to take specific actions in your journey to productionize your Generative AI-based application.

1. Choose the right Generative AI model or service for the task

Start with the basic understanding of various models that you can use and how they fit your requirements. The earlier section might have provided you a high-level overview. To move to the next step of choosing the right model or
service, explore some of the popular comparison/benchmarks for Generative AI models such as:

Chatbot Arena Leaderboard provides comparison of various LLMs based on various benchmarks. Their official website provides more utilities for comparison.
Open LLM Leaderboard provides comparison of Open Source LLMs based on various benchmarks.

While these general benchmarks can help with high level filtering of the models/services you might want to use, one must test these models against their full application requirements using a large enough sample to prove production
readiness. Assess accuracy, relevance, runtime, and other performance metrics for your use case.

2. Manage prompt engineering effectively

To effectively use a Generative AI model/service, you need to provide and iterate on prompts. Your service quality depends on it. Which is why managing your prompts for the AI services is crucial in production. Following techniques
can help

Curate a library of tested base prompts - Start by gathering prompts used during prototyping that yield high quality, relevant outputs in your domain. These can serve as standard building blocks.
Log all prompts and iterations - Track all prompts and model versions in your production systems, along with key metric scores. Analyze for continuous refinement.
Implement prompt templating conventions - Structure prompts into clear components like task framing, content constraints, tone/style parameters, etc. to simplify iteration.
Build a prompt enrichment pipeline - Augment prompts with external data like lexicons, knowledge bases, and human feedback to improve them over time.
Control variations with conditional parameters - For user personalization or experimentation, rely more on conditional tuning of style, length, etc. rather than fully custom prompts.
Allow spaces for innovation - Leave room within composable prompt templates to keep introducing and testing new creative variants.

3. Monitor quality and mitigate hallucinations

Once you see that your solution is working on your local or for some users, you must not stop there, you still need to think about quality control via monitoring and specifically to manage hallucinations. Some of the following
techniques can help.

Automate testing process to identify issues early - You can use LLM as an evaluation tool to automate some of the tasks in the testing process. Run those tests before releasing the new version to customers.
Set up monitoring for model drift - As data patterns/distributions shift over time, monitor drops in prompt effectiveness and update appropriately.
Check outputs for consistency - Spot check generations directly for coherence, factuality, toxicity to catch model performance regressions requiring prompt tuning.
Controlled beta access - We recommend releasing controlled beta access to test the product quality and identify hallucinations. It ensures the application hits quality requirements, establishes a clear user agreement, and protects key reputation aspects during closed beta with selective users.
Human review as the last defending line - You should also have a human review step for some of the different test cases before deploying the release to customers.

4. Wrap as a production API/service

Expose core functionality via REST or other APIs for easy integration into the application front-end. Add input validation, authentication, monitoring, etc.

5. Establish scalable infrastructure

Standard generative models have significant system resource demands. Even when you’re using the services which are taking care of those scalable infrastructure needs (e.g. GPT API), the number of requests you’ll be sending to those services
will be quite high and that will require you to think about your infrastructure.
Assess expected request loads and build a distributed cloud infrastructure for cost-efficient scalability. You will likely need to containerize using
Docker/Kubernetes and set up auto-scaling.

6. Setup rate limiting for cost optimization and service abuse protection

When it comes to load management, the requirements for Generative AI-based applications are way higher than your usual systems. The amount of service load is humongous as your system is talking to an external Generative AI service at a frequency which your normal app usually wouldn't need. You and your customers will frequently find dealing with errors such as “429 - Too many requests” and CPU usage going close to 100%. Avoiding these issues and the requirement of low latency is critical to retain your customers.

It is not easy, and making your application accessible from a service availability or cost perspective is fundamental to grow adoption for your product. If you use the right tools, rate limiting and caching can be easy pickings in ensuring your service does not go out of service or becomes
unsustainably expensive to manage.

Tools such as FluxNinja Aperture can be helpful, which are purposefully designed to protect Generative AI-based applications from abuse
and high cost.

As shown in the above architecture diagram, FluxNinja Aperture or your own custom solution for rate limiting needs to sit in between your app’s backend and
Generative AI service to takes care of:

Rate limiting request based on the quota for your Generative AI service
Queuing requests to avoid overwhelming your system or the external Generative AI service system you use
Prioritizing requests based on user tiers
Caching requests to reduce external AI service costs and deliver results to user faster
Monitor your service health and how you’re interacting with the external AI service

Using FluxNinja, all these steps can be done with a simple sdk integration of FluxNinja in your code. It can provide you protection from abuse as well as control your costs.

In the end, this step will result in a better user experience and boost your app’s growth.

Treat these 6 steps as a checklist for going from prototype to production.
Appreciate your thoughts and tips to make this checklist even better.

Conclusion

The Generative AI-based application market is growing exponentially. There is an opportunity to use this to grow and stay ahead of your competition. Although it is not an easy task to take your Generative AI-based product from prototype to production, it is totally possible to achieve it, similar to how CodeRabbit built a cost-effective Generative AI-based app. And you can make it easier by approaching in the organized manner and utilizing the right tools, as we discussed in this article. Some of the key points to remember are - choose the appropriate model, manage prompts effectively, use testing techniques specific to Generative AI-based apps, implement rate limiting and caching.

Modern AI stack for developer productivity

gitcommitshow — Fri, 05 Jan 2024 00:00:00 +0000

The 'modern AI stack for developer productivity' refers to a comprehensive set of AI-powered developer tools that improve developer productivity in building software. In 2023, Large Language Models (LLMs) caused significant disruption, leading to a rapid increase in the adoption of artificial intelligence within the development lifecycle, particularly in the realm of 'developer productivity tools'. A significant majority of software development projects are now leveraging some form of AI, specifically Generative AI to transform traditional development workflows into more intelligent, efficient, and automated processes.

The modern AI stack for developer productivity is reshaping the landscape of software development, making tasks that were once time-consuming or complex more manageable and automated. From helping with the research or code writing to reviewing code and ensuring quality, the modern AI stack is a testament to how AI is not just an add-on but an integral component in the software development process.

Are you leveraging the full potential of the modern AI tech stack in your projects? This article might help you to get that perspective needed to understand how it might elevate your work to the next level.

Three Pillars of the Modern AI Stack for Developer Productivity

There are three key components in the modern AI stack for developer productivity that are useful in different stages of the development lifecycle. These three stages are the research or knowledge gathering stage, the coding stage, and the final code review stage. Let’s discuss each of these stages in detail and how AI tools can help improve developer productivity in each.

Knowledge

The Knowledge pillar is central to the modern AI stack. It involves AI systems helping developers gather and synthesize knowledge, usually in the form of a chat or question-and-answer session. A prime example in this space is ChatGPT

ChatGPT is the leading AI assistant to quickly answer developers' questions on syntax, frameworks, debugging, etc.
It acts like a supercharged search engine, saving developers time from having to dig through documentation or StackOverflow.
ChatGPT can also explain concepts, provide code examples and suggestions, and identify knowledge gaps. Over time, these models will get better at technical reasoning with more training data.
StackOverflow Community Search is another product in this category which instantly summarizes the solution.

This transformation is crucial in developing environments where quick access to information and rapid problem-solving are essential.

Challenges

One of the main challenges is ensuring the accuracy and reliability of the answers. AI systems might sometimes generate plausible but incorrect or biased responses.

Code Generation

Code generation through AI marks a significant leap in software development. AI models, trained on vast code repositories, can now assist in generating code snippets and at times the entire modules. This speeds up the coding process. The evolution of this pillar is a testament to AI's growing understanding of programming languages and logic, offering a collaborative tool that augments the developer's capabilities rather than replacing them.

AI models like OpenAI’s GPT-4 Code Interpreter are leading this segment.
They aid in writing code, offering suggestions, and even generating entire code blocks based on user input.
They are particularly beneficial in increasing development speed and making coding more accessible to non-experts.
GitHub Copilot introduces this experience in the IDE (such as VS Code) where you code. It enhances coding efficiency by rapidly suggesting code blocks and functions directly within the editor. This helps developers generate boilerplate code, complete repetitive tasks and implement common patterns much faster.

Challenges

The limitations include dependency on the training data, which may not always represent the most efficient or modern coding practices. Ethically, there are concerns about code originality and the potential for inadvertently generating vulnerable or buggy code.

Code Review

AI’s role in code review is about ensuring quality, compliance, and optimization. Unlike traditional code reviews, which are time-consuming and prone to human oversight, AI-driven code reviews are swift and more thorough. AI models can scan code for patterns, anomalies, and compliance with coding standards, offering insights and suggestions for improvements. This pillar has evolved from basic syntax checking to sophisticated analysis, significantly enhancing the code quality.

Automated code review tools, like CodeRabbit, help in identifying bugs, evaluating whether the PR achieves its objectives, and ensuring adherence to coding standards. The in-line comments make it easier to use and put things in motion.
These tools can analyze code more thoroughly and quickly than human reviewers, leading to higher quality software. This frees up developer time as well as improves code quality before reaching production.
Over time, CodeRabbit could fine-tune to a team's specific code review checklist and feedback provided in comments to provide even more accurate suggestions and extend this access to organization knowledge via code reviews naturally.

Challenges

If there is not enough information about the requirements in the issues, the PR assessment against the requirement might not provide the accurate picture as you would expect.

Prioritize knowledge and review over generation

While most people would be attracted by the promises code generation offers, I believe it will not have as big an impact on developer productivity as the other two - Knowledge and Code Review.

Code Generation tools may save some time in writing standard code, understanding and fine-tuning the output remains crucial. But the risk of overreliance on AI for code generation can lead to code inaccuracies and legal issues with AI-generated code. The real productivity gains come from improving organizational knowledge and code review process to ensure high standards of code quality.

As StackOverflow rightly mentioned

The hardest part of building software is not coding, it is requirements

Software is more than just code; it's about meeting the users' need. The knowledge and code review pillar tightly align with this goal. Which is why I urge you to prioritize Knowledge and Code Review tools in your modern AI stack.

Conclusion

The integration of these three pillars - Knowledge, Code Generation, and Code Review - forms a robust foundation in the AI-driven development process. Each pillar complements the others, creating a synergistic environment where developers are empowered with advanced tools and insights, leading to more efficient, innovative, and error-free software development.

How we managed GPT-4 API cost at scale

gitcommitshow — Fri, 29 Dec 2023 20:55:36 +0000

Since its inception, CodeRabbit has experienced steady growth in its user base, comprising developers and organizations. Installed on thousands of repositories, CodeRabbit reviews several thousand pull requests (PRs) daily.

In this blog post, we will explore how CodeRabbit managed to deliver continuous, in-depth code analysis cost-effectively, while also providing a robust, free plan to Open Source projects.

Overview of CodeRabbit's Product and LLM Usage

CodeRabbit is an AI-first PR Review tool that uses GPT APIs for various functionalities. CodeRabbit offers the following tiers of service:

CodeRabbit Pro: A paid service providing in-depth code reviews for private repositories. It's priced according to the number of developers, starting with a full-featured 7-day free trial.
CodeRabbit for Open Source: A free service offering in-depth code reviews for open source (public) repositories.
CodeRabbit Free: A free plan for private repositories, providing summarization of code changes in a PR.

Our vision is to offer an affordable, AI-driven code review service to developers and organizations of all sizes while supporting the open source community. We are particularly mindful of open source projects, understanding the challenges in reviewing community contributions. Our goal is to reduce the burden of code reviews for open source maintainers by improving submission quality before the review process begins.

CodeRabbit's review process is automatically triggered when a PR is opened in GitHub or GitLab. Each review involves a complex workflow that builds context and reviews each file using large language models (LLMs). Code review is a complex task that requires an in-depth understanding of the changes and the existing codebase. High-quality review comments necessitate state-of-the-art language models such as gpt-4. However, these models are significantly more expensive than simpler models, as shown by the 10x-30x price difference between gpt-3.5-turbo and gpt-4 models.

Model	Context Size	Cost per 1k Input Tokens	Cost per 1k Output Tokens
GPT-4	Up to 32k	$0.06	$0.12
GPT-4	Up to 8k	$0.03	$0.06
GPT-3.5 Turbo	Up to 16k	$0.003	$0.004
GPT-3.5 Turbo	Up to 4k	$0.0015	$0.002

gpt-4 model is 10-30x more expensive than gpt-3.5-turbo model

Our primary cost driver is using OpenAI's API to generate code review comments. We will share our cost optimization strategies in the following sections. Without these optimizations, our free offering to open source projects would not be feasible.

Let's take a look at the strategies that helped us optimize the cost and improve user experience.

1. Dual-models: Summarize & Triage Using Simpler Models

For less complex tasks such as summarizing code diffs, simpler models such as gpt-3.5-turbo are adequate. As an initial optimization, we use a mix of models, as detailed in our earlier blog post. We use gpt-3.5-turbo to compress large code diffs into concise summaries, which are then processed by gpt-4 for reviewing each file. This dual-model approach significantly reduces costs and enhances review quality, enabling us to manage PRs with numerous files and extensive code differences.

Additionally, we implemented triage logic to skip trivial changes from the review process. We use the simpler model to classify each diff as either trivial or complex, as part of the same prompt used for code diff summarization. Low-risk changes such as documentation updates, variable renames, and so on, are thus excluded from the thorough review process. This strategy has proven effective, as simpler models can accurately identify trivial changes.

By using this dual-model approach for summarization and filtering out trivial changes, we save almost 50% on costs.

2. Rate-limiting: Enforcing Fair Usage

Upon launching our free service for open source projects, we noticed individual developers using it as a coding co-pilot by making hundreds of incremental commits for continuous feedback. CodeRabbit, designed for thorough code reviews unlike tools such as GitHub Copilot, incurs high costs when used in this manner. Therefore, we implemented hourly rate-limits on the number of files and commits reviewed per user, to control excessive usage without compromising user experience. These limits vary across different product tiers. For example, we set more aggressive limits for open source users compared to trial and paid users.

To implement these rate-limits, we evaluated various options for Serverless environments. We opted for FluxNinja Aperture for its simplicity and policy sophistication. We were already using Aperture for managing OpenAI rate limits, making it a natural choice for our rate-limiting needs as well.

In FluxNinja Aperture, policies are decoupled from application logic through labels, enabling new policy additions without altering application code. We apply labels in FluxNinja Aperture, wrap the review workload with its SDK, and write policies that enforce limits on those labels. For example, we enforce a 3 reviews per hour limit (1 review every 20 minutes) for open source users, allowing a burst of 2 back-to-back reviews, as shown in the screenshots below.

Integration with FluxNinja Aperture SDK

Rate limiting commits per hour for open source users

Wait time feedback to the user in a comment

Given the high cost and capacity constraints of state-of-the-art models such as gpt-4, rate-limiting is an essential requirement for any AI application. By implementing fair-usage rate limits, we are saving almost 20% on our costs.

Rate limit metrics for open source users

3. Caching: Avoid Re-generating Similar Review Comments

We believe that building user habits around AI involves seamlessly augmenting existing workflows. Therefore, AI code reviews must be continuous: they should trigger as soon as a PR is opened and incrementally update the summary and generate review comments as more commits are added.

However, this approach can become expensive and generate repetitive feedback, as similar review comments are re-generated for each commit. We observed that most incremental commits involve minor adjustments or bug fixes in the initial implementation. To address this, we implemented a caching layer to avoid re-generating similar review comments for incremental commits.

Fortunately, Aperture also provides a simple caching mechanism for summaries from previous commits, using the same API call where we implemented rate limits. During each incremental review, we use the simpler model for a semantic comparison of the code changes described in both summaries. If the changes are similar, we skip the review for those files to prevent re-generating similar review comments. This method differs from vector similarity-based caching techniques, as we use an LLM model for comparing summaries. Vector similarity-based approaches wouldn't be effective in our case, as the summaries require semantic comparison. We have integrated this method into the same prompt used for code diff summarization and triage.

By using the more cost-effective gpt-3.5-turbo model as an advanced similarity filter before invoking the more expensive gpt-4 model for the same file, we have saved almost 20% of our costs by avoiding the generation of similar review comments.

Conclusion

In this blog post, we briefly discussed how state-of-the-art LLMs such as gpt-4 can be expensive in production. We also shared our strategy of using a combination of simpler models, rate limits, and caching to optimize operational costs. We hope our experiences can assist other AI startups in optimizing their costs and developing cost-effective AI applications.

Does this PR effectively resolve the linked issues, here's how AI can help answer this

gitcommitshow — Mon, 18 Dec 2023 05:11:23 +0000

In this blog, we'll explore the common challenges developers encounter in assessing PR against an issue and then we'll introduce CodeRabbit, a leading AI-driven PR review copilot, as an automated solution to assess PRs.

Check out an example of assessing PR against the linked issues for PR autolab/Autolab/pull/2016 (this assessment was done by CodeRabbit PR review bot).

Let’s deep dive and understand the topic of PR assessment

Assessing PR against linked issues

For a PR reviewer and author, the most important question is:

How effectively does this PR address the issue?

It is the job of us developers to evaluate how effectively the PR addresses the objectives of the issues. Although it is obvious to many of us but understanding the context of PR assessment deeply will help us make better and quicker judgement as developers.

Before we dive into how, let's understand why.

Why do we need to assess whether a PR effectively achieves the issue objectives

Assessing whether a Pull Request (PR) effectively addresses an issue is a fundamental aspect of PR review process for several reasons:

Ensuring correctness: It's crucial for maintaining the integrity and functionality of the software.
Quality control: By rigorously evaluating a PR against the issue it purports to resolve, the team can maintain high standards of quality. This process helps in identifying any potential bugs, performance issues, or unintended consequences introduced by the PR. Having the assessment written in the PR gives a good sense to the author and the peer reviewer.
Prevent unnecessary work: Effective assessment ensures that time and effort are not wasted on PRs that do not fully resolve issues, preventing the need for additional fixes or rework in the future.
User satisfaction: In cases where issues are user-reported or significantly affect user experience, ensuring that a PR effectively resolves the issue is key to maintaining user trust and satisfaction.
Learning and improvement: The process of assessment provides valuable learning opportunities for developers. It allows them to understand more about the system, the nature of the problem, and the effectiveness of their solution.

What stops developers from assessing PR against an issue correctly

There are several challenges associated with this assessment:

Time pressure: Under tight deadlines, there might be a rush to get PRs merged, which can lead to insufficient assessment and oversight.
Limited context: Reviewers might not always have full context or deep knowledge about every aspect of the issue, which can lead to challenges in accurately assessing the PR.
Complexity of Issues: Some issues can be complex, with subtle nuances or hidden dependencies. Understanding whether a PR fully addresses such issues can be difficult.
Subjective evaluation: Assessment can sometimes be subjective, especially in cases where the issue and the solution are not strictly technical but involve user experience, design, or other qualitative aspects.
Inadequate Testing: In some cases, the lack of comprehensive testing can hinder the assessment. If a PR is not thoroughly tested in various scenarios, it might be difficult to ensure it completely resolves the issue.

So what can we do about it?

Solution : CodeRabbit’s AI-powered assessment against linked issues

CodeRabbit PR review bot analyzes the issue in depth, understanding the objectives. Then based on the code diff, it analyzes whether those objectives are met or not. The result along with the explanation is shown in the PR summary or comment. The PR author or peer reviewer then quickly get a sense which objectives were met (marked ✅), which which not met (marked ❌), and which were unclear to make a judgment (marked ❓).

See it in action:

autolab/Autolab/pull/2016

appsmithorg/appsmith/pull/29375

SickChill/sickchill/pull/8640

To get this feature, just install the CodeRabbit PR review app in your GitHub repository. Deep dive into how CodeRabbit works.

Conclusion

It is a fundamentally essential task for PR authors and reviewers to assess whether the PR effectively resolves the related issues or not. We discussed how this simple-looking task could be challenging due to reasons such as limited context and time pressure. CodeRabbit’s AI-powered PR review bot solves these challenges by automatically validating linked issues against PR.

AI-powered GitHub app to automatically link issues in a PR

gitcommitshow — Sat, 09 Dec 2023 03:56:42 +0000

It was year 2012, I was a junior developer back then. My colleague watches me copying link to a GitHub issue and sharing it in a Pull Request (PR). He comes to me and tells me that I can simply write the issue no. and it will be automatically linked. I am blown away with this tiny feature because it solves a major pet peeve I have.

If we can go back in time to tell this guy that you don't even need to search and write the issue no. and your related issues will automatically get linked in PR, younger me would probably go uncontrollably mad with the the joy.

In case you didn't know, it is here! We don't need to link issues in a PR now, an AI code review bot does a better job than us humans in finding the relevant issues and linking those with the PR.

We might do a good job in linking just the one issue for which we worked on that PR but this bot can also find all those issues this PR impacts. Seemingly tiny but impactful feature.

In this blog, we'll explore the reasons why one must link related issues to PRs. We'll highlight the common challenges developers encounter in doing so. And then we'll introduce CodeRabbit, a leading AI-driven PR review copilot, as an automated solution to linking issues with PR.

Check out an example of linking related issues for okp4/ontology/pull/220 (these issues were linked automatically by CodeRabbit PR review bot).

Let’s deep dive and understand the topic thoroughly.

Linking related issues to PR

For developers and PR reviewers, there are two fundamental questions to consider for every PR:

What is the key issue this PR is tackling?
What are the broader implications of this PR on other existing issues?

And these questions are answered by identifying and connecting related issues to the PR. So this is apparent for many of us developers but let's understand the context in depth what does issue linking helps with.

Why do we need to link the related issues for a PR?

Finding related issues for a Pull Request (PR) is an essential practice with significant importance for several reasons:

Prevents redundant work: When issues are not linked to PRs, developers miss to close them, it can lead to issues not getting closed even after it has been fixed. Another developer spends time researching and developing only to realize later that it was already fixed by another issue. Another common problem is often duplicate issues get logged due to a disconnect. Linking issues to PRs prevents them from remaining open after resolution, averting duplicate efforts and confusion caused by other developers unknowingly working on these fixed issues. It streamlines the development process.
Better PR reviews: When reviewers are aware of related issues, they can provide more informed and comprehensive feedback. This helps in identifying potential oversights or conflicts that might arise due to the new changes.
Better issue tracking and documentation: When PRs are linked to issues, it creates a clearer historical record of why changes were made, which is valuable for future reference and new team members. If there are non technical folks on the team, they also get a good sense on what issues are now solved thanks to this PR.
Fosters collaboration: When an issue is linked to PR team members can see the context and history of a problem, which helps with better understanding and more efficient problem-solving.
Improved code quality: Understanding the wider implications of PR changes ensures that the code not only fixes a specific problem but also aligns with related issues.

What makes it hard for developers to link related issues in PR

Let's be honest, finding and linking these issues is neither a developer's favorite pastime nor it is as easy as it sounds. Let’s explore the challenges developers face in linking related issues:

Oversight: Many times, developers are not aware of larger impacts to the code base. Which leads them to miss linking all the issues the PR is addressing. This is more common where the project and the codebase is not small enough or requires a significant amount of collaboration with others.
Lack of adherence to standard practices: Inconsistencies in how issues are reported, described, or tagged can make it difficult to find related issues. Lack of standard practices in issue tracking can lead to inefficiencies.
Searching in a large project takes time: For large projects with extensive issue histories, manually searching and identifying related issues can be a daunting and time-consuming task.
Difficulty in identifying relationships: Understanding the interdependencies between different parts of a complex codebase can be challenging. This complexity might cause developers to overlook related issues.
Information overload: In large projects, the sheer volume of issues can be overwhelming, making it difficult to sift through and identify the most relevant ones.

Solution: CodeRabbit (a PR review bot) automatically finds those issues using AI

CodeRabbit, an AI-powered PR review bot, simplifies this task by analyzing GitHub issues, performing the similarity search and linking the most relevant ones to your PR. See it in action:

okp4/ontology/pull/220

ethereum-optimism/docs/pull/261

usatie/pong/pull/111

How to automate issue linking with PR

To get this feature, just install the CodeRabbit PR review app in your GitHub repository. That's it. If you're curious to understand how does app work behind the scenes, check out this CodeRabbit deep dive blog.

Conclusion

It is an essential task for PR authors and reviewers to identify issues related to the PR. We discussed how this simple-looking task could be challenging due to many reasons including oversight and project complexity. CodeRabbit’s AI-powered PR review bot solves these challenges by automatically linking issues in the PR.

DEV Community: gitcommitshow

[Boost]

GitHub action to make your website analytics fail-proof and free from vendor lock-in

GitHub action to make your website analytics fail-proof and free from vendor lock-in

The Problem - Analytics breaks silently

First, make your analytics free from vendor lock-in using RudderStack SDK

Second, make your analytics fail-proof using AI-powered GitHub workflow

Mastering Code Review skills using AI tools

How to Assess Code Review Skills and Improve

1. Set a Time Limit for Reviewing New PRs

2. Utilize Automated AI Tools

3. Compare and Reflect

4. Repeat and Learn

5. Seek Feedback from Coworkers

Why Self-Assessment Works

The Benefits of Mastering Code Review

Conclusion

Boosting Engineering Efficiency Using AI Code Reviews for Remote Teams

Direct Correlation: Remote Engineering Challenges & AI Solutions​

Real-World Applications & Pitfalls​

Common Pitfalls & Solutions​

Actionable Takeaways

CodeRabbit – An AI Code Reviewer​

Steps for Effective Integration and Adoption​

Balancing AI Assistance with Human Touch​

Conclusion​

FluxNinja Aperture v1.0 - Managed rate-limiting service, batteries included

The world needs a managed rate-limiting service

Overview of FluxNinja Aperture

Challenges with traditional rate-limiting solutions

How FluxNinja Aperture solves these gaps

Customer case study

Conclusion (tl;dr;)

Prototype to Production Roadmap for Generative AI-based Products

Understanding foundational Generative AI models and services

Text generation and processing

Image generation

Voice generation

Music or Sound generation

Video generation

General purpose

Future categories

Path from prototype to production

1. Choose the right Generative AI model or service for the task

2. Manage prompt engineering effectively

3. Monitor quality and mitigate hallucinations

4. Wrap as a production API/service

5. Establish scalable infrastructure

6. Setup rate limiting for cost optimization and service abuse protection

Conclusion

Modern AI stack for developer productivity

Three Pillars of the Modern AI Stack for Developer Productivity

Knowledge

Challenges

Code Generation

Challenges

Code Review

Challenges

Prioritize knowledge and review over generation

Conclusion

How we managed GPT-4 API cost at scale

Overview of CodeRabbit's Product and LLM Usage

1. Dual-models: Summarize & Triage Using Simpler Models

2. Rate-limiting: Enforcing Fair Usage

3. Caching: Avoid Re-generating Similar Review Comments

Conclusion

Does this PR effectively resolve the linked issues, here's how AI can help answer this

Assessing PR against linked issues

Why do we need to assess whether a PR effectively achieves the issue objectives

What stops developers from assessing PR against an issue correctly

Solution : CodeRabbit’s AI-powered assessment against linked issues

Conclusion

AI-powered GitHub app to automatically link issues in a PR

Linking related issues to PR

Why do we need to link the related issues for a PR?

What makes it hard for developers to link related issues in PR

Solution: CodeRabbit (a PR review bot) automatically finds those issues using AI

How to automate issue linking with PR

Conclusion

Direct Correlation: Remote Engineering Challenges & AI Solutions

Real-World Applications & Pitfalls

Common Pitfalls & Solutions

CodeRabbit – An AI Code Reviewer

Steps for Effective Integration and Adoption

Balancing AI Assistance with Human Touch

Conclusion