DEV Community: haimzlato

The Next Generation of No-Code: AI, Code, and Diagrams

haimzlato — Tue, 08 Apr 2025 08:05:59 +0000

Automation today is largely driven by no-code and low-code tools, enabling users to create workflows—sequences of tasks across multiple systems that achieve business goals—without needing to write code. However, no-code/low-code as it exists today is set to change. With AI advancements, the traditional approach of visually designing workflows will evolve into a more dynamic, AI-assisted paradigm. In this article, we propose a different way to build automations in the AI era—one that blends AI, visualization, and code for greater flexibility, reliability, and ease of use.

The Strengths and Limitations of No-Code

No-code tools like Zapier, n8n, and Workato make automation more accessible by removing the need to write code or manage execution behind the scenes. They’re great for building and managing relatively simple workflows, offering an intuitive, visual interface that makes automation easy to create and understand.

However, these tools come with notable limitations:

Limited flexibility – Most no-code tools are based on static, linear flows (DAGs) and can only handle a limited number of steps.
Slow adoption of new APIs – No-code platforms often lag in supporting emerging services, which can be a challenge in fast-moving areas like AI and modern digital tools.
Limited control – No-code solutions are typically black boxes, offering limited support for error handling, retries, or recovery—making them less suitable for mission-critical applications.
High costs – Pricing can quickly become expensive as usage scales.

Low-code tools improve on this by allowing developers to inject code into workflows, offering more flexibility and control. But by introducing code, they naturally become more developer-focused.

The Shift Towards AI-Powered No-Code / Low-Code

No-code/low-code automation is evolving from traditional drag-and-drop workflow builders to AI-powered prompt-based systems. This shift is evident in application builders like Lovable and Bolt, as well as automation platforms such as Zapier, 8n8, Workato, and others. These tools now allow users to define automations using natural language prompts, with AI generating initial workflow structures that users can refine and validate through visualization. Also, many automations will be done by AI Agents where the flow might be fuzzy sometimes, but good enough.

I believe this is only the beginning — the real transformation lies ahead. With the rise of AI tools and prompt-based development (like vibe coding), traditional no-code platforms may start to feel limited and less relevant.

How No-code Automations Are Built Today

Building automations—or applications in general—typically involves three main phases:

Planning – Defining the flow of what needs to be automated.
Creating the execution code– The code under the hood that implements the automation logic.
Monitoring – Tracking execution, debugging, and reviewing outcomes.

In no-code platforms, from the user’s point of view, planning and creating the execution code are combined into a single step through the visual interface, and the monitoring can also be viewed on the same interface, indicating the execution progress.

With AI-enhanced no-code tools, users describe their needs in a prompt, and AI translates them into an initial visual workflow. This process can be iterative, allowing users to refine and adjust as needed. Before execution, users can visually validate and fine-tune the workflow:

The Future of Automation: AI with Text-based Interface, Visualization, and Code Generation

As prompts become the primary interface for building automations, the value of traditional no-code tools comes into question. If users can describe what they want in natural language, AI can handle both the logic and the visualization. Visual representations are still useful—for review, validation, and explainability—but these too can be generated by AI.

The future of automation is not about dragging blocks on a canvas. It’s about users interacting with AI through text, building high-level plans that are instantly translated into code and visual workflows. This hybrid model—textual interface, AI-assisted logic, and generated visuals—offers the flexibility of code with the accessibility of no-code.
.

Here’s what that could look like:

Users interact with AI through prompts to define a high-level automation plan. The AI responds with a visual representation of the workflow in diagram form.

Once the user is satisfied, the automation can be launched—just like in traditional no-code platforms. But unlike no-code tools, there’s no need for a proprietary automation infrastructure. Behind the scenes, the entire process is implemented in code (e.g. in Python) which brings many advantages: flexibility, transparency, version control, and long-term maintainability.

Today’s large language models (LLMs) are capable of generating functional code for the vast majority of use cases currently handled by no-code platforms. And even when the output isn’t perfect, users can iterate with the AI to resolve issues. In edge cases, some basic coding skills may be needed—but that’s a small tradeoff for the added power and control.

Beyond initial development, AI can further assist by:

Suggesting and implementing error-handling strategies.
Enhancing logging and monitoring capabilities.
Acting as an advisor for optimizing workflows.

The Missing Piece: Tools and Execution

If AI can generate both code and visual workflows from prompts, what else is needed? Why not just take the code and deploy it directly?

The answer lies in what no-code platforms have always done well: they bring together critical components that make automation work in the real world—like integrations with third-party services (e.g., Gmail, Slack, and hundreds more), triggers like webhooks and schedulers, execution infrastructure, access controls, monitoring, and lifecycle management.

Writing the code is often the easy part. Getting that code into production, running reliably at scale, with proper error handling, observability, and security—that’s the hard part.

The future of automation may be in a platform that brings together:

AI-assisted planning and code generation
Seamless execution without infrastructure headaches
Integrations to applications
Webhooks, scheduled tasks
Primitives and tools for supporting long-running workflows
Workflow development and management tools

This hybrid model offers the best of both worlds: the power and flexibility of code, combined with the simplicity of AI-driven automation. This approach is becoming increasingly important as APIs evolve rapidly and new tools emerge—most of which are built for code first. In contrast, no-code platforms often lag behind, requiring time-consuming updates to support new integrations.

As automation evolves, AI-assisted code generation isn’t just a replacement for no-code—it’s the next step forward.

** With this in mind, we built AutoKitteh.

Hacking the Python Import System and Rewriting the AST For Durable Execution

haimzlato — Wed, 18 Dec 2024 13:02:44 +0000

At AutoKitteh, we run users’ Python code as-is in a way that can redo parts of the execution in case of failures.
This article explains the magic.

In a nutshell, AutoKitteh uses Temporal to run the user code. It takes the user code and converts functions, such as ml.enrich, into temporal activities. The user code changes function call from event = ml.enrich(event) to event = _ak_call(ml.encrich, event) Where _ak_call does the following:

This magic is implemented by AST rewriting.
For more information, read the article.

Build Limitless Automations in Python - "Zapier" for Developers

haimzlato — Thu, 07 Nov 2024 08:14:16 +0000

Links: Beta registration, website, GitHub, examples

Autokitteh's Beta is now open!!!

AutoKitteh is an automation platform specifically designed for Python developers. It's like "Zapier for developers," enabling you to build limitless automations with just a few lines of code.
Unlike, low-code platforms like Zapier, Make, 8n8, and many others, it allows you to build automations in a very simple way, without the limitations of no-code. It's easily extendable and provides almost the full power of Python and the benefits of code such as versioning, enabling easy code reviews etc.

The main features of the product:

Automate tasks using just basic Python code.
Execute long-running, reliable workflows. It ensures your processes are durable and can resume exactly where they left off—even after server restarts.
Easily connect to applications like Slack, Gmail, GitHub, and many more.
Define custom triggers for your workflows.
Deploy with a single click—no infrastructure required.
Manage and monitor your workflows.
Can be easily extended to connect any API

The target audience is professional and citizen developers familiar with Python that build personal projects or enterprise solutions.

AutoKitteh is designed for:

DevOps, IT and MLOps automation
Personal and office workflows

*Comparison to other products
*
AutoKitteh is an integration platform similar to Zapier, Make, and Workato. However, instead of focusing on no-code solutions, it offers a low-code interface that leverages the power of Python for developing business logic.

Additionally, it functions as a durable workflow engine like Temporal and Inngest, providing a transparent Python interface.

*Availability
*

Self-hosted, open-source - GitHub
SaaS (Free) - Register to SaaS Beta

Durable Python: Building Bullet-Proof Long-Running Workflows, Made Simple

haimzlato — Wed, 04 Sep 2024 14:06:26 +0000

In modern software development, creating robust workflows that connect APIs from various services and handle both synchronous and asynchronous events is a common challenge. The conventional approach involves using a mix of queues, microservices, and state management systems to build scalable applications. While effective, this architecture comes with significant overhead: setting up and maintaining infrastructure like message queues, running servers or lambda functions, managing state in databases, and implementing complex error-handling mechanisms.

What if there was a simpler, more reliable way to handle long-running workflows without the hassle of managing all this infrastructure? That's the goal of Durable Python, to try it, register to Beta.

The Problem with Naive Solutions for Long-Running Processes

Imagine you want to monitor pull requests (PRs) in GitHub. Each time a new PR is opened, you’d like to create a dedicated Slack channel for discussion and send daily reminders until the PR is closed or merged. This sounds straightforward, so you might think you can solve it with a basic Python function (here’s a basic Python function generated by ChatGPT):

@app.route('/webhook', methods=['POST'])
def github_webhook():
    data = request.json
    if 'pull_request' in data and data['action'] == 'opened':
        pr_number = data['pull_request']['number']
        pr_url = data['pull_request']['html_url']
        # Create a new Slack channel for the PR
        channel_id = create_slack_channel(pr_number)
        send_slack_notification(channel_id, pr_number, pr_url)
        # Periodically check the PR status and send reminders until it's closed or merged
        while True:
            time.sleep(3600)  # Wait for 1 hour before checking the status again
            pr_status = check_pr_status(pr_number)
            if pr_status == 'open':
                send_slack_notification(channel_id, pr_number, pr_url)
            else:
                break
    return jsonify({'status': 'ok'})

This code snippet seems to handle the task, but it's only suitable for the “happy flow” scenario. In real-world applications, this naive approach falls short. The while loop relies on continuous server uptime, which isn’t guaranteed. Processes can crash, servers can restart, and suddenly, your workflow is broken.

Real-World Solution: Event-Driven Applications

A more reliable approach involves building an event-driven application. Here, you would use queues to listen for GitHub events, cron jobs to send reminders, databases to store the PR and channel state, and functions to handle these events. Typically, this setup runs on cloud infrastructure, leveraging services like AWS Lambda for deployment and execution.

While this method is feasible and robust, it also requires considerable setup, maintenance, and expertise. Managing the infrastructure, ensuring uptime, and handling error states demand significant resources and a skilled team.

Enter Durable Python: Simplicity Meets Reliability

What if you could combine the simplicity of the naive Python code with the reliability of an asynchronous design? What if Python could guarantee that even if a process crashes or the server restarts, it would pick up right where it left off?

AutoKitteh addresses precisely this challenge with Durable Python. Using Durable Python, the user writes Python code while the system ensures that if a process restarts, it continues running from the same point. While there are limitations (e.g., long downtime might not be ideal), for most use cases, this solution works perfectly.

What Durable-Python Offers

Durable-Python saves you from managing state manually, allowing you to write your workflow as a continuous flow rather than an event-driven state machine, which can be challenging to build and debug. AutoKitteh, as an infrastructure, has built-in queues and integrations with external applications and APIs, making it easy to quickly develop robust workflows in Python.

How It Works

There’s no magic involved—just solid engineering. AutoKitteh is powered by Temporal, a framework for building durable workflows. Temporal requires a specific way of coding, including an understanding of determinism, idempotency, and other concepts to ensure reliability. AutoKitteh abstracts these complexities, allowing developers to write standard Python code. Under the hood, any function with side effects is converted into a Temporal activity. As a developer, you don’t have to worry about these details—just focus on writing the business logic.

For more technical details, refer to the AutoKitteh documentation.

Is There a Cost?

Of course, every abstraction has a price. Under the hood, Durable Python records the flow of the workflow to enable recovery after failure, which incurs some storage and performance costs.

Durable Python is designed for the orchestration of APIs rather than building data applications. If you need high-performance applications, you should consider building a custom solution. However, if you want to quickly develop reliable workflows with minimal development and infrastructure investment, Durable Python might be a good option.

Real-World Applications

Durable Python can be applied to a wide range of workflows, particularly in domains where reliability is crucial, such as:

API orchestration - build internal reliable workflows.
DevOps Automation: Automate deployment pipelines or code review automation with guaranteed recovery from failures.
ChatOps: Integrate with chat platforms to automate team notifications and manage workflows.
MLOps: Ensure long-running machine learning workflows continue seamlessly despite interruptions.

Examples to worflows can be found here.

Conclusion: Less Code, Less Hassle

Durable Python concept, implemented powered by AutoKitteh, empowers developers to build, deploy, and manage reliable workflow automation with minimal code. The durable execution and seamless recovery are handled behind the scenes, so you can focus on what truly matters—your business logic.

While there are many excellent tools for achieving durability (like Temporal and Restate), Durable-Python provides a fast, simple, and cost-effective way to achieve the same results.

Room Reservations for Last-Minute Meetings in Slack, Python Automation

haimzlato — Fri, 30 Aug 2024 19:05:37 +0000

Managing meeting room availability can be a challenge in busy organizations, especially when it comes to last-minute, ad-hoc bookings. To address this, I developed a Python-based automation tool that seamlessly integrates Slack with Google Calendar, allowing employees to quickly check room availability and book rooms for immediate meetings.

The Python code is short and easy to modify, can be found here
The code if designed for a platform called AutoKitteh, which is an open-source project, repo.

In many companies, meeting rooms are managed as resources within Google Calendar. Each room is associated with a unique email account, and employees can add these rooms to their calendar invites.

We created a simple Slack interface that enables users to quickly and easily manage ad-hoc bookings, making it ideal for meetings that need to be scheduled within the next 30 minutes (it can be easily modified to any other time frame). The system utilizes three custom Slack slash commands:

/availablerooms - This command lists all available meeting rooms within the next 30 minutes.

/roomstatus - By entering room name, users can check the status of a particular room for the next couple of hours, including whether it's available or booked.

/reserveroom - Allows users to reserve a specific room for their meeting, providing the room name and meeting title that will be added to the calendar invite.

Invite in Calendar:

Implementation:
The automation listens for events in Slack and uses APIs to interact with Google Calendar and Google Sheets. Here’s a breakdown of the process:

Room List Management: A Google Sheet serves as a simple database, listing all room email addresses. This setup can be easily modified to include additional details such as room aliases, locations, or capacities. Example of Google Sheets setup:

1  room1@example.com
2  room2@example.com
3  room3@example.com

Integration: The Python scripts handles authentication and communication with Google Calendar, google Calendar and Slack APIs, processing user commands and updating the calendar in real-time.

For additional useful automation examples, see here.

Useful automations using Slack, GitHub, Jira, Google tools and more

haimzlato — Wed, 28 Aug 2024 11:38:23 +0000

we built relatively simple but useful automations in Python deployed on AutoKitteh using integrations to various applications such as GitHub, Slack, Jira, Google Calendar, Google sheets and more. For example:

Categorize new emails in your Gmail inbox using ChatGPT and send notifications to the appropriate Slack channel.
Automatically set JIRA ticket assignees based on Google Calendar events.
Scan your Copilot users and request them to free up licenses if not used for two weeks.
"Break Glass" - Using Slack to orchestrate a temporal elevation of privileges in AWS. A developer asks for privileges in Slack using Slash command, the IT team can approve on deny in Slack form. If approved, the workflow elevates privileges in AWS and reduces back after some period of time.

All are written in Python, very short and easy to modify, see code and additional automations.

You can install the platform and run automation on your PC / Cloud or ask access for the cloud service.