Inspiration
Slit did not start with “we have this amazing app idea.”
Actually, it started almost the opposite way.
Ken and I are both computer science students, and before this project we had a very simple question:
How thin can a product be and still be useful enough that someone would actually pay for it?
We were joining the RevenueCat Shipaton, but we did not want to immediately open Xcode and start building the first idea that sounded cool.
So first, we made a lot of guiding questions.
Things like:
- What problem do people complain about repeatedly?
- What can we realistically build in a short period of time?
- Do people already try to solve this manually?
- Is there already demand, even if the existing solutions are not perfect?
- What is the smallest feature that can create a real “oh, this is useful” moment?
- And probably the most important one: are we solving a problem, or are we just excited to code something?
We explored a lot of ideas. Probably too many.
Meeting recorders, break reminders, AI tools, storage tools, automation, even very random Mac utilities.
At one point our own team agreement literally included:
NOOOOOOOOT jumping to conclusions.
Which is funny because, as CS students, jumping straight into implementation is exactly what we naturally want to do.
Eventually, one problem kept appearing: Macs getting slow or running out of application memory while people were actually trying to work.
We saw creators, developers, designers, students, and people using heavy apps reaching the same moment:
the Mac starts struggling, the spinning wheel appears, and suddenly you are debugging your computer instead of doing your actual work.
That is where Slit started.
What it does
Slit is a lightweight memory manager for macOS.
The idea is intentionally simple.
It helps you understand what is using your RAM, see which applications are consuming the most memory, and free memory without needing to constantly open Activity Monitor or restart your Mac.
We did not want Slit to become another giant “clean your entire Mac” application.
The product is supposed to be a very thin layer between the user and something macOS already exposes, but in a way that is much easier to understand.
Basically:
your Mac starts slowing down → open Slit → understand what is heavy → free memory → continue working.
That is the loop.
Our goal is not really to make people think about RAM more.
It is kind of the opposite.
We want them to think about it less.
How we built it
We built Slit natively for macOS using Swift and SwiftUI.
That choice was pretty important for us.
It would feel strange to build a memory utility that itself is a huge, heavy application running in the background, so we wanted Slit to stay lightweight and feel like something that belongs on the Mac.
A lot of the work was around reading system memory information, identifying running applications and their resource usage, and then turning that information into something a normal person can understand.
Technically, macOS can already tell you a lot.
The harder question was:
Which information should we actually show?
As CS students, it is very tempting to expose everything because all the numbers are interesting.
But most people do not want a systems lecture.
They want to know:
“Why is my Mac slow and what can I do about it?”
So we kept reducing the interface.
We also integrated RevenueCat for the paid side of the app and worked through the whole process of actually making this a product: pricing, App Store setup, landing page, screenshots, onboarding, testing, privacy documents, distribution, and all the boring things that suddenly become very real when you are not building a class project anymore.
And honestly, that part was a big part of the challenge.
Writing the feature was only one piece.
Shipping the feature was another problem entirely.
Challenges we ran into
One of the biggest challenges was scope.
We originally mixed together ideas around storage management, System Data, caches, RAM monitoring, performance, cleaning, and a bunch of other things.
Everything felt related.
But if everything is part of the product, suddenly the “simple utility” becomes another CleanMyMac-sized project.
So we had to keep asking:
Does this make Slit more useful, or does this just make Slit bigger?
That question killed a lot of features.
Another challenge was explaining memory without making the app feel technical.
Words like RAM, memory pressure, cached memory, swap, processes, and compression make sense to us because we study computer science.
But that does not mean the user wants to see them.
We learned that sometimes building the technically correct interface is much easier than building the understandable interface.
There were also macOS constraints.
System utilities touch areas of the operating system where you cannot simply do anything you want. Sandboxing, permissions, App Store rules, APIs, and process behavior all forced us to change some ideas.
And then there was distribution.
We entered this project wanting to learn not only how to build a product, but how to actually get people to use it.
That was uncomfortable.
Coding is deterministic most of the time.
You write something, it breaks, you debug it.
Distribution is different.
You can make a video you think is great and nobody cares.
You can explain a feature and realize nobody understands why it matters.
You can have an app that works and still have zero users.
That was probably one of the biggest mindset changes for us.
Accomplishments that we're proud of
The thing I am most proud of is honestly that we shipped it.
As a computer science student, I have built many prototypes.
Projects that work on my machine.
Projects made for a class.
Projects where the final milestone is basically the presentation.
Slit was different because the finish line was not:
“the code works.”
The finish line was:
someone who does not know us can find this app, understand it, download it, use it, and potentially pay for it.
That forced us to work on things we normally ignore:
- App Store distribution
- Pricing
- Monetization
- Product positioning
- Landing pages
- Content
- User testing
- Branding
- Screenshots
- Onboarding
- Privacy
- Actual customer feedback
We are also proud that the product became smaller during development instead of bigger.
That sounds weird as an accomplishment.
But I think one of the hardest things we did was deleting ideas.
We started with a much broader concept of Mac storage and performance management.
Slit became much clearer once we accepted that it did not need to solve every problem on the Mac.
It just needed to solve one moment really well.
What we learned
The biggest lesson was that building software and building a product are very different things.
As CS students, we are trained to think:
problem → implementation → working solution.
But real products are more like:
problem → assumption → user → wrong assumption → research → prototype → another wrong assumption → implementation → feedback → change it again.
We learned that writing code too early can actually make you more attached to a bad idea.
We also learned that a product does not need to be technically revolutionary to be useful.
Slit is not inventing RAM.
macOS already has Activity Monitor.
The interesting part is whether we can create a better interaction around a moment where the current experience has too much friction.
That changed how I personally think about product ideas.
Before, I often looked for something technically impressive.
Now I think more about:
What annoying thing already happens every day, and can we remove one step from it?
Another lesson was that distribution cannot start after the product is finished.
We originally treated marketing almost like the last item on a checklist.
During this project we started sharing the process, testing messaging, talking about the problem, making content, and trying to understand which people actually cared.
Some of it worked.
Some of it definitely did not.
But that was part of the experiment.
What's next for Slit - The Memory Manager
The next step is to see whether Slit deserves to become bigger.
Not whether we can add more features.
We definitely can.
The question is whether users actually need them.
We want to keep observing where people struggle after using the first version.
Maybe that means smarter memory monitoring.
Maybe better alerts before the Mac becomes unusable.
Maybe helping users understand which applications repeatedly consume too much memory.
Maybe deeper tools for creatives who push their Macs really hard.
But we want the next feature to come from a repeated user problem, not from us sitting in front of a whiteboard saying:
“this would be cool.”
Slit started as an experiment around building a very thin product.
So for now, we want to protect that idea.
Make it small.
Make it understandable.
Make it useful.
And then let the users tell us how much bigger it needs to become.
Log in or sign up for Devpost to join the conversation.