Build Faster and Smarter with AI and Best Practices

Artificial intelligence is rapidly changing software development. But software development fundamentals have not changed.

You need reliable, maintainable, scalable integrations. To get there, you need a process that drives consistency, adheres to proven patterns, and enables the expertise of those building, deploying, and managing integrations.

In our recent post on how we will incorporate AI into Prismatic and related processes, we noted that one area of focus is using AI to make it even easier for you to build integrations. And we know that easier can't come at the cost of creating solid, scalable integrations. That's why we want to make it straightforward to use AI assistants such as Cursor and Copilot to build custom components faster, while ensuring compliance with integration development best practices.

To this end, we have created and publicly shared an AI ruleset and related best practices for our Spectral SDK to support faster, smarter development of custom components.

We'll cover how AI plus Spectral power responsible development shortly. But first, let's look at Spectral.

Understanding our Spectral SDK

Prismatic enables non-devs (via the low-code integration designer) and devs (via code-native integrations) to build the integrations their customers need. Central to our dev experience is Spectral, which we use internally (and our customers use externally) to write components and integrations entirely in code.

Because our developers designed Spectral to build the software that powers Prismatic integrations, it works well with modern development tools and enables robust, testable TypeScript projects.

While the SDK allows devs to create powerful and complex custom components and integrations, understanding a third-party API and wrapping it in a high-quality custom component can still require substantial work. How can you build these components rapidly, as your customers and integration needs scale?

That's where AI assistants come into the picture.

Understanding AI assistants and the patterns they follow

We are familiar with providing prompts when working with chatbots like ChatGPT, Claude, and Gemini. When developing code using an AI assistant, the assistant incorporates our ruleset into the initial prompt behind the scenes. The ruleset includes additional instructions detailing how the AI should behave while completing the original prompt.

These instructions comprise best practices that cover development principles, standard project layouts, requirements for testing and validation, and more. In short, everything necessary for your AI assistant to successfully create a custom component that looks like what you would have written if you built everything slowly by hand.

Our rulesets integrate directly into your developer workflow. There's no separate Prismatic AI. Instead, we guide the AI assistants your devs may already use. And if your team isn't using these assistants yet, leveraging the expertise we provide with Spectral and these rulesets offers a practical reason to consider them.

While the provided ruleset captures our recommended practices based on extensive experience, we understand it is only a starting point. We encourage you to adapt and customize it, incorporating your standards and patterns into our baseline.

Putting it all together

Here are examples of how an AI assistant, guided by the Prismatic ruleset in our GitHub repository, can accelerate Spectral development, assist with porting logic, and enforce quality for custom components.

The developer carries on a conversation with the AI using a series of prompts (starting with the one shown) to execute each example. As with a human conversation, the prompts will vary based on what the AI has already done and the options available for next steps. More details on prompting and how to guide the conversation are available at the top level of our GitHub repository.

Example 1: Develop a new custom component

• Prompt: "Help me create a component that wraps the API @docs.my-messaging-service.com while referencing @start-new-component.md"
• Result: The AI assistant will reference the linked API docs and Prismatic's "Start New Component" prompt to help you create a new custom component that wraps the given API. start-new-component.md tells the assistant how to write a Prismatic custom component. The assistant will then analyze our rules and the API docs, scaffold out a file structure, and then create a list of tasks in a tasks.md file for you to review. This task list consists of everything the assistant believes is needed for the component, including actions and connections. At this point, you can review the task list, edit it as necessary, and move forward by prompting the assistant with @next-task.md.

Example 2: Add actions to an existing component

• Prompt: When working in the context of the MyMessaging component: "Add a trigger for when a new channel is created" or "Add a 'Get User Details' action."
• Result: To ensure that the AI assistant understands key concepts from the Prismatic SDK, we include the necessary context in .cursor/rules/component-dev.mdc. Every time you open a new conversation with the assistant, this file is loaded into its context with your prompts. Then, after adding our best practices to your project folder, the assistant can augment your existing custom components with new features. For best results, divide your requests into separate conversation contexts.

Using AI with rulesets to uplevel your integration process

The challenge of B2B SaaS integrations isn't just building the integrations but building them well, especially at scale. Combining the flexibility of Spectral for code-based development with an AI assistant guided by rulesets results in a structured, repeatable process that leads to properly designed code.

As a customer, you can use Spectral with AI to increase velocity, embed proven patterns, and ensure that your team follows best practices, no matter how many custom components you build.

This is just the start. We will be extending this model into more development areas soon. These updates will include rulesets for creating new code-native integrations and converting Prismatic's low-code integrations into code-native integrations.

Schedule a demo and explore how leveraging Prismatic with AI and rulesets will boost your integration development velocity.