DEV Community: Jonathan Harel

The Disposable Software Era

Jonathan Harel — Tue, 22 Apr 2025 10:18:36 +0000

Not every app needs to last. Some just need to work, right now.

Not every app needs to scale.

Some apps just need to exist for a single hour, a single task, or a single person.

We’re entering the era of disposable software: apps that are created quickly, used immediately, and discarded without a second thought. It sounds radical, but it might just reshape how we think about building, sharing, and using software altogether.

Software Is Becoming Ephemeral

For decades, building software meant cost, complexity, and commitment. You needed engineers, infrastructure, and preferably a business case. But things are shifting. The rise of AI, no-code platforms, and prompt-based app creation has collapsed the cost of building. You can now spin up a functional app in seconds, sometimes with nothing more than a sentence.

Building apps no longer belongs solely to engineers. It’s becoming fast, expressive, and lightweight. This mirrors what happened with photography: Once upon a time (less than 50 years ago), taking a photo required expensive gear, technical skills, and physical film. Then smartphones came. Suddenly, anyone could capture a moment without friction. That didn’t turn everyone into a professional photographer, but it did unleash a creative revolution.

This creative revolution was powered by disposable media: Snaps, Tweets, Stories. We could suddenly create content for the moment, without the pressure of permanence. We don’t worry whether a selfie will be remembered in five years, we just post it, and move on. And increasingly, software is starting to behave the same way. That evolution makes something new inevitable: Disposable software

The Rise of Disposable Software

Disposable software is software built for short-term use, apps that serve a specific purpose and then disappear. Not because they’re broken, but because they were never meant to last. They exist for a moment, solve a problem, and quietly fade into the background.

This shift isn’t a gimmick, it’s inevitable. Just like we embraced disposable media, we’ll embrace disposable software. Once creation becomes effortless, permanence becomes optional. When the barrier to build collapses, usage patterns evolve. We don’t save every photo. We don’t archive every Tweet. Soon, we won’t keep every app either.

In a way, this model is the next evolutionary step in how we interact with computers. For decades, computers were rigid, you had to learn the tools, understand the UI, and conform to what existed. Now, we’re entering an era where the computer creates the tool you need, on demand, based on your intent. You don’t adapt to the software, the software adapts to you.

Think of a one-off app to organize chores for this week, or a custom RSVP tool for Saturday’s event. Like disposable cameras or Instagram stories, these apps aren’t designed to live forever, they’re designed to be useful right now. It’s software as content, not infrastructure. Personal, ephemeral, and often playful.

And this is already happening more than you think:

A one-day app to split bills for your weekend trip
A gift tracker built just for this year’s holidays
A microsite to tease a side project you may or may not pursue
A quick dashboard for your kids’ morning routine

Each of these apps solves a real problem. But turning them into a startup? That’s a leap. Finding an existing tool that does exactly what you want, free, fast, frictionless, is often surprisingly difficult. And even if you do find it, signups, learning curves, and feature bloat makes you think you might as well just build something quick that works and move on.

Why It Matters

Now, you might be thinking: “But wait! That’s a nightmare to maintain. Software should be reliable, tested, production-ready!”

Yes, and that’s exactly the point. Disposable software does NOT need to be maintained. It’s NOT built to last. It’s built to do its job and disappear. And that shift lowers the stakes in a way that unlocks something beautiful.

When there’s no pressure to scale, maintain, or monetize, people start building freely. They experiment. They create without worrying if it’s "worth it." Suddenly, people who’ve never written code can make tools that genuinely help themselves or others.

It also opens up whole ecosystems of micro-solutions that would’ve never existed under traditional development costs. Instead of one app generating a billion dollars, we’ll see a million apps each solving niche, hyper-personal problems, some generating $10, some $0, but all meaningful.

Software is no longer just infrastructure. It’s becoming an expression.

So what happens next?

What does the world look like when generating a disposable app becomes as fast and natural as writing a text? Do we still need massive, one-size-fits-all platforms for everything? Will we still visit dedicated signature platforms like DocuSign, or will we just prompt a custom signer when we need it and throw it away the moment after?

Will people build tools for their neighborhood WhatsApp group the same way they make a meme, on a whim, with zero friction?

And if that’s the case, what does that mean for the definition of software itself? When creation is instant and expectations are low, does software become less about polish and more about intent?

At Fine, we believe software should feel like posting online, light, expressive, and instant. If this vision resonates, you’re not alone. We think this is just the beginning.

Creating a Custom Captive Portal for Home WiFi with Raspberry Pi and AI Magic

Jonathan Harel — Sat, 30 Sep 2023 21:00:00 +0000

Ever wondered about the magic behind those WiFi login pages that greet you at places like Starbucks? You know the drill – you sip your coffee, pull out your laptop or smartphone, connect to the WiFi, and voilà! Suddenly, you're redirected to a page where you need to log in or accept terms before diving into the digital realm. It's a seamless experience we've all grown accustomed to, but have you ever thought about creating one yourself? Well, probably not. But I did! And there’s a good reason why.

I live in Ruppin street, and as a joke, I call my apartment the “Royal Ruppin Relax” as if it was some kind of a boutique hotel. I wanted to create my own customized WiFi login portal, so that guests at my home would get a surprise when they log in. That's what we're diving into today: In this tutorial, I’ll show you how to build and customize your own captive portal – a digital gateway that not only controls access but also acts as a canvas for your creativity, and a great conversation starter! With a Raspberry Pi and a bit of AI magic, you can transform your mundane WiFi login into an engaging, personalized experience.

But first, What is a Captive Portal?

The term might sound technical, but in essence, it's the official name for those login pages you encounter when connecting to a public WiFi network. Most captive portals are like virtual gatekeepers, ensuring that only authorized users gain access to a WiFi network. But this interface can be a powerful tool, not just for authentication, but also for conveying information and engaging users creatively.

Capabilities of a Captive Portal:

Authentication: Captive portals authenticate users by prompting them to enter login credentials or accept terms and conditions. This process ensures that the network is used responsibly and securely.
Customization: One of the features of a captive portal is its customization potential. Businesses often use captive portals to showcase their branding, display advertisements, or provide essential information.
Access Control: Captive portals enable administrators to control the type of access users have to the internet. For instance, they can restrict certain websites, limit bandwidth, or provide different levels of access based on user roles. So technically, you can configure it such that your devices are prioritized bandwidth wise on your WiFi network, but that’s up to you 😉

Now, let's move forward and create our own captivating captive portal. The creative journey begins!

You Will Need:

Before we dive into creating your personalized captive portal, let's gather the essentials:

Raspberry Pi: The heart of your project, this versatile microcomputer will serve as the central hub for your captive portal setup.
MicroSD Card: You'll need a microSD card (at least 16GB) to store the operating system and other necessary files.
Power Supply: Ensure you have a compatible power supply for your Raspberry Pi to keep it running smoothly.
Ethernet Cable: You'll require an Ethernet cable to establish a wired connection between your Raspberry Pi and your internet router.

Why Raspberry Pi?

In the landscape of network devices, not all routers are created equal. Many standard routers lack native support for captive portals, making it challenging to implement this feature seamlessly. When faced with this limitation, we turn to Raspberry Pi as a solution. This credit-card-sized, affordable computer will allow you to run complimentary network related software, and overcome the constraints of your existing router.

If you never used your raspberry pi before, set it up according to the simple instructions on the official website. Our next step would be installing RaspAP.

RaspAP: Simplifying WiFi Management

Now that you have your Raspberry Pi ready, it's time to introduce RaspAP. RaspAP is an open-source software that simplifies the process of setting up a WiFi access point on your Raspberry Pi. Think of it as the bridge between your Raspberry Pi and the devices that will connect to your WiFi. To install RaspAP, simply follow the simple instructions on the official website.

Why Do We Need RaspAP for a Captive Portal?

‍To create a captive portal, we need a WiFi network that's entirely under our control. RaspAP allows you to do just that: While Raspberry Pi provides the hardware backbone, RaspAP adds the user-friendly interface, making it incredibly easy to configure your WiFi network settings. You can customize the network name (SSID), set up passwords, and manage the connection preferences. RaspAP handles the complexities of access points, security protocols, and IP addresses, ensuring that the WiFi network your guests connect to, operates smoothly and securely.

Why Is an Ethernet Cable Needed?

‍You might be wondering about the necessity of an Ethernet cable in a wireless setup. When you connect your Raspberry Pi to your router using an Ethernet cable, you establish a stable, wired connection. This wired connection serves as the foundation upon which you'll build your customized WiFi network.

Introduction to Nodogsplash

Now that you've set up your WiFi access point with RaspAP, it's time to introduce Nodogsplash into the mix. Nodogsplash is a high-performance Captive Portal and the key player in bringing our idea to life. Nodogsplash offers by default a simple splash page that we will customize later. Install and configure Nodogsplash by following the easy tutorial on RaspAP’s official documentation. If you are successful - you will see this page:

Customizing the Splash Page

Here comes the exciting part! Now we will customize the captive portal page to our liking. Customizing the splash page might seem like a challenging task for two reasons:

Nodogsplash Rules: Nodogsplash has specific rules that the splash page must adhere to, ensuring functionality. Deviating from these rules might result in our captive portal not working, making it crucial to comply with them.
CDCs force us to work with HTML and CSS only, no JS. A CDC (Captive Detection Client) is a component in operating systems or devices that helps in detecting whether a network has a captive portal. When a device connects to a WiFi network, the CDC functionality checks if the network connection is restricted by a captive portal. If it detects a captive portal, the device redirects the user to the portal's login or authentication page. Most of the CDCs don’t allow JS or even hrefs, so we will have to work with HTML and CSS only to make a beautiful captive portal. Manipulating HTML & CSS requires a good understanding of their syntax, making customization challenging for many users.

To overcome these challenges, we will use some ✨ AI magic ✨.

First, we will obtain a stunning boutique hotel picture with Leonardo AI: an innovative tool that generates realistic and visually appealing images from prompts. Here’s how you can use it:

Visit Leonardo AI: Go to the Leonardo AI website and click on “AI Image Generation”
**Generate Your Image: **Using Leonardo AI's intuitive interface, generate an image that resonates with your captive portal's ambiance. You can tweak various settings until you find the perfect image. My prompt was: “A beautiful boutique hotel next to the sea, palms and luxurious atmosphere, beautiful day”
Download Your Image: Once satisfied with the generated image, download it to your computer. This stunning visual will serve as the backdrop for your customized splash page.

Now that we have the image, we can customize the default HTML and CSS. To do that we will use Fine’s AI agents, that can quickly get us to the point:

Deploy an HTML Agent to Your workspace: Open Fine and click “Deploy Agent”. Upload the YAML file of the HTML Agent, found here. This agent specializes in HTML and CSS tasks.
Create a project: Place the default Nodogsplash files in a folder, together with your generated image. Run git init inside the folder and then add it as a new project to Fine.
Create a Notebook and specify the changes you want to make: The agents work according to a plan specified in a notebook. I wrote a short description for my wanted task and connected the notebook to the project.
Run the agent, and make some final tweaks: The agent will start changing the HTML and CSS pages according to the specifications in your notebook. If it isn’t exactly to your liking, make the final changes and that’s it!

With Fine’s AI agents, the process of customizing your splash page becomes intuitive and efficient. You don’t need to deal with HTML and CSS, and you don’t need to learn the rules of Nodogsplash. You easily transform a basic login interface into a visually appealing and engaging portal that captivates users, providing a memorable WiFi experience.

Test Your Customized Page:

After Fine generates the code, test your customized splash page. To do that, upload your files to the raspberry pi and replace the default splash page files in

/etc/Nodogsplash/htdocs/

Ensure that it complies with Nodogsplash rules and provides a seamless user experience. Make any necessary adjustments until you achieve the desired result.

Final Words

By integrating Raspberry Pi, RaspAP, Nodogsplash, Fine, and Leonardo AI, you've not only created a functional captive portal but also unleashed your creativity without the headache of coding intricacies. This project not only enhances your technical skills but also transforms your WiFi experience at home. Feel free to experiment further and explore the endless possibilities of customization, all thanks to the power of innovative AI technology.

Now it's your turn to improve your home WiFi experience! Get creative, get connected, and let your imagination run wild, AI will take care of the rest!

Eating Our Own Dog Food

Jonathan Harel — Thu, 21 Sep 2023 08:15:30 +0000

‍There are many ways to validate your product and to get feedback. At Fine, we're not only changing the game in software development, but we're also making sure that we are on the right path by "eating our own dog food."

"Eating your own dog food" is a popular phrase in the tech industry. It means using your own product or service in your daily operations. It's a testament to your belief in your product's capabilities and its ability to solve real-world problems. At Fine, we wholeheartedly embrace this philosophy.

How Fine uses Fine: Building the Future of Software Development

Fine is on a mission to accelerate software development to the maximum. With a vision to replace the traditional IDEs, we're pioneering a new era in software creation. But how do we prove that our platform is not just a concept, but a practical solution for developers and businesses? We do it by using Fine to build Fine. We don't just talk the talk, we walk it.

Fine is not just a product; it's the operating system for Software 3.0. We firmly believe that Fine is the way we will build software in the future, and we're proving it every day by using it to build itself. From managing tasks to streamlining features, Fine has become an integral part of our development process.

Here are the benefits we get from using Fine internally

Accelerated Development: Fine enables us to build, iterate, and release new features faster than ever before. Even our community members are surprised at how fast we are moving:

Quality Assurance: Our AI agents ensure that code quality remains top-notch, reducing bugs and enhancing reliability.
Team Collaboration: Fine fosters collaboration among our developers, creating a seamless workflow. We also have a better understanding of what other devs in Fine decided to build, since we have the specifications they wrote for each task.
Continuous Improvement: By using Fine internally, we gain firsthand insights into its strengths and areas for improvement, allowing us to refine the platform continuously.

What I like the most about these benefits is that they directly relate to the features that separate us from the competition:

First, let’s look at our core promise. While coding assistants like GitHub Copilot have revolutionized coding, they primarily focus on the next few lines of code. Fine, on the other hand, takes a giant leap forward by providing developers with AI agents capable of handling complete software tasks. Each agent is an expert in its field, and when combined with a codebase, they run with extreme accuracy, significantly boosting productivity.

We get to verify that every day. We are a small team, but we move fast because we have virtual teammates that help us with all kinds of features.

Second, let’s consider Fine’s uniqueness: Unlike many competitors that target individual contributors (ICs), Fine is designed with businesses and teams in mind. We prioritize teamwork, privacy, and the creation of multi-agents. Fine isn't just a tool for solo developers; it's a platform that empowers entire teams to work smarter and faster.

We are building Fine as a team, and so we immediately see what helps us and what slows us down. By tasting our own medicine we truly get to assess the quality of our product.

Join Us in the Future of Software Development

As we eat our own dog food, we invite you to join us on this exciting journey. Fine isn't just a tool; it's a paradigm shift in software development. Whether you're a developer eager to 10x your development speed or a forward-thinking company ready to embrace the future, Fine has something extraordinary to offer you.

At Fine, we're building a future where software development is faster, more efficient, and more collaborative than ever before. By using Fine to build Fine, we're not only putting our money where our mouth is but also leading by example.

Join our Discord community today, and let's shape the future of software development together!

From Producing a Web Series to Founding a Startup: Fine’s Journey.

Jonathan Harel — Thu, 14 Sep 2023 08:42:03 +0000

This week we released the first version of Fine - a platform for building software with AI agents. It took us almost a year to get here, and the journey was filled with challenges and accomplishments, together with failures and disappointments. I wanted to take a moment to share my experience with you, and I hope that you will find inspiration in our story.

A different way to ideate

About a year ago, our team of three founders started our ideation process. We wanted to build something we would enjoy using, and seeing that we are programmers, we were interested in the area of developer tools. We knew that every good startup is based on a great problem, so we set out looking for worthy problems developers face. The common way to do that is by conducting interviews with future clients, so we were looking to interview leading R&D execs in order to hear all about the problems their organization faces.

Now, these R&D execs are busy people. We can’t just reach out to them and expect them to make time for us. Add to that the fact that conducting customer interviews is not an easy job. You need to get the interviewee to open up, and don’t expect them to say “This is EXACTLY the problem I’m facing”. The way we solved this problem? We decided to produce a documentary web series, and have them participate in it. If we convince the companies to participate, we thought, we will get direct access to every person we want to interview in the organization. And that’s exactly what happened.

We went on to create Dark{mode}, the first web series about developer experience (later, it became the largest tech web series in Israel). We spent over 60 hours interviewing R&D executives from companies like Wix, Taboola, AppsFlyer, and AI21 Labs. We told the participants in advance that “the conversations are going to deal with everything that doesn’t work. Don’t tell us the good stories”. And so, during the interviews we got to hear about all the problems that affect developer experience. The talks uncovered 81 "blockers" that hinder progress in the tech world, and range from the fields of PRs and Design to Communication and Team Work.

The approach we took had its pros and cons. You can probably guess that producing a web series is not an easy task. It involved more people than we initially anticipated, required content verification by the featured companies, and demanded collaboration with numerous service providers to maintain a high-quality standard. All of this consumed precious hours that could have been devoted directly to our startup. However, this unconventional path had its advantages. We gained direct access to the interviews we needed and garnered attention in Israel's tech scene, making it easier to connect with investors.

The Birth of Fine

Inspired by the challenges we uncovered during our interviews, we started looking for ways to make a meaningful impact. Three critical factors guided our thinking throughout this process:

Anticipating the Future: We continuously asked ourselves where the software world was headed. What solutions would be in demand not just today but tomorrow as well?
Leveraging Our Skills: We assessed our team's unique skill set to understand how we could best support our idea.
Embracing New Technologies: We kept a keen eye on emerging technologies that were previously unavailable.

Eventually, after iterating on a few ideas, we envisioned an AI powered platform where developers get the most assistance in building software. We were not happy with only boosting their productivity, we wanted devs to be able to delegate entire software tasks to AI. We imagined that devs would only have to deal with what they want to build, and not with how. Content with our idea, we started putting it out there and talking about it with everyone we can and trying to raise initial capital.

Our journey didn’t start smoothly. In a market still uncertain about the future of AI in software development, securing funding was no easy task. The first three months were marked by relentless pitching, numerous rejections, and an industry on edge. But we refused to be discouraged; we decided to focus on building our vision, believing that Fine's true potential would become evident with time. We also realized that if we will truly stand to our promise, we will be able to use our own product to continue building it — a concept called "eating your own dog food."

Early Milestones and Building a Community

Our journey gained momentum as we started building the platform. We launched a Discord community and sought early adopters willing to try Fine. Gradually, our community expanded, and Fine garnered attention online. I personally engaged with new Discord users, gathering feedback to refine our product and progress beyond the Proof of Concept stage.

The interviews with community members helped us understand that we need to set ourselves apart from competitors by prioritizing collaboration and teamwork, protecting privacy, and allowing the creation of multi-agents.

After three more months, our hard work paid off when we secured our first client. It was a pivotal moment for us, a testament to the potential of our product and the dedication of our team. Our user community continues to grow, with almost 400 users joining the Fine journey, eager to explore the future of software engineering.

What’s next for us

Today we are releasing the first version of Fine. Learning from our past mistakes, we will onboard a limited number of users, and provide free credits to help them get started. During our launch week we expect to find oh-so-many bugs, fix issues, and be more engaged with our community. Updates will continue to roll out, but you can expect us to follow Supabase’s “Launch Week” pattern, which is a great best practice for startups.

Throughout this year of challenges and countless rejections, our vision for Fine remained our guiding light. It may sound like a startup cliche, but it genuinely sustained us during the tough times. It's crucial to maintain a bold yet clear vision. Ours is to replace the traditional IDE and become the definitive entry point for software development. This vision fuels our determination, especially when faced with adversity.

Our journey is far from over. We know that the road ahead will be long and filled with challenges, but we are determined to keep our eyes on the ultimate goal. Every email, every breakthrough, and every step forward brings us closer to realizing our vision. The story of Fine is just beginning, and I invite you all to be a part of it. Together, we can redefine the future of software development and bring about a new era of productivity and creativity.

If you are a software developer, I invite you to join us today on this exciting journey, and make something extraordinary together. Our product is waiting for you here, and our Discord community is where you can get help and support.

Introducing Fine: the IDE of the Future

Jonathan Harel — Wed, 13 Sep 2023 09:30:30 +0000

Over the past few weeks, we have been refining our product in collaboration with our early adopters. We have spent hours engaging with software engineers, CTOs, and engineering leaders. Using the feedback we gathered, we have developed a significantly improved version of Fine that we are releasing today.

The future of software engineering

In recent years, the process of software development has become increasingly complex. Developers are required to be familiar with many frameworks that serve very specific needs and change rapidly and constantly. From writing code to cloud deployment, every single developer must deal with a huge mental load. You might have seen this post on Reddit, that got a lot of attention:

The future of software engineering lies in enhancing the joy of creation, allowing developers to enter a seamless flow where they focus on “what” instead of “how”. Fine let’s AI handle routine tasks, and frees engineers to focus on problem solving. This transformation turns mundane tasks into exhilarating ones, aligning with the true purpose of our work – building valuable products and escaping the hassles of version updates and deployments.

Software 3.0 Changes The Game

Software 3.0 marks a paradigm shift. It prioritizes design over coding and brings engineers closer to the essence of their job: problem solving. At Fine we’re learning about the best practices in Software 3.0, rethinking workflows from the ground up, and codifying them into our product.

Real change comes when tools create new habits and change our behaviors.

As we transition into the era of Software 3.0, developer-oriented products increasingly concentrate on novel workflows rather than merely enhanced tools. Here's a glimpse into the Software 3.0 workflow embraced by Fine:

Write Specifications: Clear specifications serve as guidelines for both AI agents and humans.
Delegate to an AI Agent: Specialized AI agents handle diverse tasks and generate the majority of the code.
Refine: Human oversight ensures changes align with the specifications.
Ace the Last Mile: Final adjustments are made by humans before shipping.

Bring the Flow Back With Fine

Today, we're not just introducing a product; we're unveiling a new way to develop software. This approach transcends the challenges of conventional software development workflows, and reignites the passion and creativity within every developer.

Fine is available for everyone, and you can get started for free. We're continuously refining our best practices and adding more integrations to elevate your experience. Here is what you can expect from us now:

Every Individual Becomes an Engineering Manager: Fine enables every developer to deploy as many AI agents as they want, akin to managing a squad of experts. With identity, tools, and workflow, each AI agent becomes an efficient part of the development process, turning every developer into a squad leader.
Built For Teams: Fine is designed for collaboration, recognizing that software creation is a collective effort. Features like organizational memory and live collaboration are integral, facilitating a “team sport” approach to problem solving, and keeping all the context in one place.
Privacy First: We are committed to safeguarding your creativity. Fine doesn’t store your code - everything happens locally, keeping your innovations private and secure.

Built with the Community

Our journey with Fine has been a collaborative effort with early adopters, software engineers, CTOs, and engineering leaders. Your insights have shaped Fine, making it a product built by the community, for the community. We encourage you to keep building with us: Join our Discord community, add your agents to the agent examples repo, and spread the word on Twitter.

We can’t wait to see what you’ll build!

FastAPI Made Faster with AI Agents

Jonathan Harel — Tue, 15 Aug 2023 12:24:47 +0000

FastAPI has redefined web development with its speed and simplicity. However, as applications grow, so do the intricacies of managing endpoints, validating input data, handling errors, and ensuring optimal performance. In this post, we'll explore how the FastAPI agent can help you move quickly with FastAPI projects. Whether you're a seasoned coder or new to the framework, the agent will optimize your workflow and enhance your development speed.

The FastAPI AI agent not only understands your project inside-out, but also knows everything about FastAPI's playbook. It combines what it knows about your work with FastAPI's instruction manual to give you the best advice. This way, the agent can help you add new parts to your API, write tests, or find and fix glitches. Put simply - it's like having a teammate who's familiar with both your project's quirks and the rules of the FastAPI game.

Real-World Use Case: Adding a Reports Feature to Your Inventory Management API

Let's dive into a practical scenario where you're adding a reports feature to your existing inventory management API, which includes endpoints for products, categories, and sales transactions. You can watch a video that covers the entire process here:

Describing the required feature

Start by specifying the reports API you want to implement, in this case it’s a simple GET endpoint that receives start and end date and returns a few numbers from the inventory data. Based on this input, the assistant can automatically generate the necessary API endpoints, complete with route paths, request parameters, and response structures. It leverages its knowledge of your API structure and FastAPI documentation to ensure the generated endpoints align with the existing design.

Activate the agent

Once the specifications are in place, the AI agent can start running. Inside the project directory we will run the command $ fine-dev proxy, that will allow the agent to operate locally. Then, on the Fine web platform, we will press ctrl+p to open the agent palette and select the FastAPI agent.

⚠️ Notice: if you haven’t deployed the FastAPI agent to your workspace, you will not see it in the list of agents. To deploy the agent, follow the instructions here.

The agent will start by providing the list of steps it intends to perform and asking for confirmation. We will confirm and move forward.

Validation and Pull Request

After the agent completed its operation, you will find that the reports endpoint was added to the main API, and that a test has been added as well. The tests follow the guidelines from the FastAPI documentation. That’s pretty great!

By leveraging AI agents, we've streamlined the process of adding a feature to our existing API. It has harnessed its knowledge of our project, combined with FastAPI best practices, to provide tailored support at every step – from endpoint generation to testing and documentation. With this help, we've expanded the capabilities of our API while maintaining code quality and adhering to FastAPI's principles.

Moving forward

If you are using FastAPI, consider exploring the possibilities that AI agents offer. While FastAPI is just one framework, AI agents can extend their support to a wide array of tools and technologies. Our GitHub repository showcases practical examples of how the AI agents can integrate with different projects, check it out!

I invite you to join us in the journey of discovering how AI agents can enhance development processes. Share your experiences and observations as you experiment with our AI agents in your projects, helping us refine and expand its capabilities. Join our discord community, develop your own custom agents, and contribute to shaping the way developers interact with code!

Using AI Agents To Get Started Quickly On Kaggle

Jonathan Harel — Thu, 10 Aug 2023 12:46:28 +0000

Discover how to overcome the repetitive setup process when working on Kaggle projects. This blog post guides you through building an AI agent to streamline PyTorch training pipelines. Learn to define steps, automate data preprocessing, and generate training loops effortlessly.

If you've spent time on Kaggle, you're likely familiar with the initial hurdles of setting up your first lines of code. The process often involves repetitive tasks, from loading and preprocessing the data to defining the model architecture, selecting loss functions, setting up optimizers, and running training loops.

While these steps are essential, they can be quite boilerplate in nature, demanding your attention each time you embark on a new project. This repetitive process not only consumes time but also requires effort that could otherwise be directed toward the core creative aspects of your project – designing innovative models, exploring unique data insights, and pushing the boundaries of what AI can achieve.

Today, I'm excited to share my journey of creating an AI agent that helps me get started quickly on Kaggle competitions by building a training pipeline in PyTorch for me. If you're new to the world of deep learning and data science, don't worry – I'll guide you through the process step by step. Let's dive in and embark on this exciting adventure together!

Step 1: Gathering Resources

Before we start coding, let's gather the tools we'll need for our journey:

Python and PyTorch: Make sure you have Python installed (version 3.6 or higher). To install PyTorch, head over to the official website and choose the version compatible with your system.
Kaggle Account: If you don't have one, create an account on Kaggle. It's an incredible platform filled with datasets and competitions that you can explore.
Fine Account: Similarly, create an account on Fine if you don’t have one. File lets you build, deploy and run agents quickly and easily.
Fine’s CLI tool: Install the CLI tool that will allow the agents to operate. You can do it by running npm i @fine-dev/cli

Step 2: Choose Your Dataset

For our first training pipeline, let's select a dataset from Kaggle. Choose something that interests you – whether it's images, text, or tabular data. Once you've found the perfect dataset, download it and unzip the files to a dedicated folder on your machine.

In this tutorial I will use the famous Titanic dataset.

Step 3: Building the Agent

It's time to introduce some automation magic into our process. Enter the agent – a trusty companion that will carry out our predefined tasks, sparing us the repetitive setup and execution steps.

In this step, I'll guide you through the process of building your agent using a workflow.yaml file. This file will serve as a roadmap for our agent, detailing the sequence of tasks it should perform. It's like providing your agent with a to-do list that it can follow diligently.

Let's get started:

Create a workflow File

In your project directory, create a new file named workflow.yaml. This is where we'll define the steps that our agent will execute.

Define Steps

Next, inside workflow.yaml give your agent an id, a name, and an identity, followed by the agent's tasks as a list of steps. Each step will have a name, id, and a list of commands:

Our workflow.yaml sets up an agent to locate a .csv file, read its content, keep the first row, and then generate a PyTorch training loop that predicts the most suitable column in the CSV. It ensures that we follow Python and data science best practices throughout the process.

Step 4: Deploying the Agent

Now that we have our agent’s workflow defined, it’s time to deploy it to Fine. To do so, follow these steps:
‍

Login to Fine

First, we need to connect our local environment to our Fine account. Run the command:

$ fine-dev login

Deploy the agent

Run the following commands from your project’s directory:

$ fine-dev deploy -p workflow.yaml

Step 5: Running the Agent

After building and deploying our agent, it’s time to take it for a spin! To do it, we need to do two things:

Download the dataset of choice

I will be using the Titanic dataset, so I downloaded the train.csv file and put in my project's directory.

Run the proxy

To allow the agent to operate, we need to set up the proxy. Run the following command from your project's directory:

$ fine-dev proxy

Run the Agent

From the Fine web interface, open a notebook and hit ctrl+p to open the agent palette. If everything went well, you should find our PyTorch Starter Agent waiting for you in the list. Select it and our agent will start running!

Step 6: Validate the Results

‍Our agent has finished running, let’s see what it created for us:

In the file src/main.py we can find the following code:

Nice! That's a great starter for our Kaggle competition.

Step 7: Celebrate Your Achievement!

Congratulations! You've successfully set up your first training pipeline in PyTorch using data from Kaggle. This is just the beginning of your journey into the exciting world of AI and machine learning.

Remember, every great accomplishment starts with a single step. Keep learning, experimenting, and don't be afraid to ask questions. Happy coding and may your AI adventures be filled with curiosity and discovery! 🚀🧠

Uhmmm... This is awkward...

Jonathan Harel — Sun, 04 Oct 2020 11:58:52 +0000

To whom of us didn’t it happen? We log in to the online meeting, and while we wait for the last colleague to join / for someone to share their screen / for a friend to fix their mic and camera, there is an awkward silence… The type that really makes you feel remote.

And so, I decided to create a solution: UHMMM automatically plays elevator music when the conversation goes silent. A century-old solution to a modern problem. It works on all platforms and with all meeting providers (zoom, meet, teams, etc…)

So… uhmmm… wanna check it out?
https://uhmmm.app/

Enjoy, and feel free to reach out!
Jonathan