DEV Community: Fine

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.

Replit vs Cursor

Dror Wayne — Sun, 26 Jan 2025 15:03:02 +0000

Why choose Cursor over Replit?
Why choose Replit over Cursor?
How you can connect cursor and replit!
Why Fine beats both Cursor and Replit
Here's the article.

Shipping UX improvements

Dror Wayne — Wed, 22 Jan 2025 12:30:00 +0000

*We've been shipping a lot of UX improvements recently. Here's how we do it.
*
1) Maintain a backlog of tasks. Don't let ideas and suggestions get lost in slack channels - list them all. We use Linear.
2) Triage tasks to decide which are most suited to AI. I can go into this more, but think tasks that would take up to 3 hours, touch up to 3 files and have clear acceptance criteria.
3) Add a label to those tasks ("AI-ready")
4) When you have the time, come back and pick 2-3 tasks to give to the AI
5) Run all three
6) Review the logs, visually verify the changes with Live Previews and make any changes needed
7) Create PR

AI Coding isn't just replacing developers

Dror Wayne — Mon, 20 Jan 2025 16:05:18 +0000

When we set out to create Fine, our plan wasn’t to “replace developers” or to get AI to write code for the sake of AI writing code.

We wanted to create an "AI teammate" experience of collaborating with AI like you'd collaborate with a colleague developer.

Well, developers need their own dev environment - with the source code, build tools, dependencies and customizations.

If we could create this AI teammate, with a dev environment of its own, in the cloud, the benefits would be awesome:
Working i

n parallel on multiple tasks
Switching between tasks with a much lower overhead
Get tasks done (or started) on-the-go
AI can work for you asynchronously, not just whilst you’re involved
Easy to test and verify the AI generated code

We’ve been working on Fine for a long time but we’re now at a stage where we can look back and see that we achieved this goal and developers are able to use their AI Teammate in their day-to-day work and not just for hobbies.

We’ve got a full roadmap of features, integrations and improvements coming over the next few months, to make your AI Teammate as versatile and useful as possible. If you’re interested in trying out coding with AI for your startup - check out fine.dev

𝐅𝐢𝐧𝐞 𝐯𝐬 𝐂𝐥𝐚𝐮𝐝𝐞 & 𝐂𝐡𝐚𝐭𝐆𝐏𝐓 - 𝐖𝐡𝐚𝐭'𝐬 𝐭𝐡𝐞 𝐝𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞 ❔

Dror Wayne — Mon, 20 Jan 2025 07:00:00 +0000

A question I've been asked regularly, so here's a breakdown on the practical differences for you as a developer.

🗨️ With Claude and ChatGPT, there's no context. If you give them a task, you;ll get a generic response, because they don't know your code.
🗨️ Alternatively, you copy and paste your code into the chat. Apart from being complex and time-consuming, you can only really do so with one file at a time.
🟣 Fine is connected to your GitHub and indexes your codebase, so it can quickly find the relevant context and write accurate, applicable code. It can edit multiple files at the same time, ensuring they work together.

🗨️ If you copy code into Claude or ChatGPT, the AI may introduce new bugs, by editing or deleting existing code - and there's a good chance you don't spot the changes.
🟣 Fine shows clear diffs and a Line Change Summary. It also creates an implementation plan, telling you what it's going to do, does exactly that, and tells you what it's done.

🗨️ To test code generated by Claude or ChatGPT, you're going to need to copy it back into your IDE to run.
🟣 Fine allows you to run, test and preview the code in the browser, whether you're accessing from your mobile or laptop.

These are just 3 of the major differences between working with the LLMs in their basic format designed for chatting and working with Fine's Agents, powered by the same LLMs, but built for developing.

For AI Coding - use an AI Coding Agent. Not an AI Chat.

New Fine Updates - Project Instructions & More

Dror Wayne — Fri, 03 Jan 2025 07:00:00 +0000

By popular request, we’ve added the ability to define your own set of custom instructions or rules for the AI Agent. Head to Projects > Project Settings > Instructions.

You can use Project Instructions to set coding style preferences and conventions, include external documentation and style guides.

Instructions will be used by the Agent for every task on the Project, from all users in the workspace.

You can apply different instructions to different projects and if you have shared instructions that you would like to apply to multiple projects, make sure to copy them into each one

Watch: Live Demo creating a tiptap editor using AI

Dror Wayne — Tue, 17 Dec 2024 13:01:52 +0000

Live Demo: Creating a Tiptap editor using AI

Watch this developer take the task from Linear, hand it off to Fine, make changes in the browser, run the code and create a GitHub PR.

Why is it successful?

🟣 Good specs
🟣 Integrated codebase for context
🟣 Manageable task size

When you're delegating tasks to AI like this, you free your dev team up to handle higher-level problem-solving and therefore
😁 Bring more delight to your customers
😁 Keep your devs more engaged
😁 Extend your startup's runway

➡️➡️➡️ Try it out for your self at 𝖿𝗂𝗇𝖾.𝖽𝖾𝗏

The AI developer assistant that feels illegal to know about

Dror Wayne — Tue, 17 Sep 2024 12:02:32 +0000

Fine hasn't been in the news as much as other AI coding tools - but it's far more powerful for (professional developers) in many ways and has been around already for 2 years.

Here's why it's different and whether you should try it out.

1) Fine has the full context
Sure, some other platforms have recently been catching up on this, but Fine's approach of indexing your repositories through GitHub really works. The team have been working for months on building the most efficient knowledge graph, which means your codebase is easily accessible to the AI when you ask a question or set a task. It's also the only AI dev tool that also indexes your issue and error management platforms, putting it miles apart from the others.

2) Fine offers pro-active workflows
The biggest time-saver with Fine is having tasks performed based on triggers. E.g. when a PR is submitted, review it; when the CI/CD pipeline fails, analyze the logs; when an issue is created, add context.
All these mean that when you as a developer get down to work on a task, you've got a headstart.

3) Fine is for building on complex projects
Twitter, TikTok and other platforms are full of viral videos of people building "entire apps" in Cursor and Replit because it looks cool - but most developers who have a startup to build or clients waiting for delivery on their projects, are barely applying the full power of AI.

Whilst the "viral" tools are making app-building accessible to beginners, Fine is changing the way professional software developers do our jobs and helping us keep a competitive edge.

Fine offers a 7-day free-trial of all pro-features. Sign up now at https://fine.dev/?ref=devto

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!