I get super excited each time I launch a new blog platform. Like this one using Ghost. Then I get bored, rarely update it, and then ultiately let it die on the vine.

I really need to come up with a solution that will use Amazon s3 and that's it. I've have websites that are hosted on S3 for the last 14 years, no updates, no deployes, nothing fancy, just websites that last.

This platform (ghost) needs a dedicated server and a database to deliver this pointless content, all of which costs money and needs continual baby sitting. I'm tired of baby sitting self hosted shit. So now I need a better alternative.

What should I do?!

This week's 'Tabs Still Open' is a wild ride through cutting-edge tech. Delve into the Damn Vulnerable MCP Server's security risks, uncover the autonomous coding power of Apex-CodeGenesis for VS Code, and explore Neuroca's organic memory for AI agents. Plus, power up your Mac workflow with AI-enhanced apps that'll turbocharge your productivity. If you crave innovation, security insights, or efficiency boosts, this roundup is your jam.

Damn Vulnerable MCP Server: Dive into Model Context Protocol Risks

Explore the deliberately vulnerable Damn Vulnerable MCP Server, showcasing 10 challenges revealing security vulnerabilities in Model Context Protocol (MCP) implementations. Learn about MCP's structured context provision for Large Language Models (LLMs) and the recommended CLINE MCP client. Dive into security risks like prompt injection and more.

Tags: Vulnerable, MCP, Server, Model Context Protocol, Security Risks, CLINE

Apex-CodeGenesis for VS Code: Coding Autonomy Unleashed

Discover Apex-CodeGenesis, an advanced autonomous coding agent for VS Code with unique features like recursive reasoning, self-critique, and dynamic personas. Dive into its total autonomy modes and extensive tool capabilities.

Tags: Apex-CodeGenesis, VS Code, autonomous coding, advanced tools, dynamic personas, recursive reasoning

Neuroca: Organic Memory for AI Agents

Discover Neuroca, a sophisticated biologically inspired memory system offering high-quality, persistent memory with self-maintenance strategies. Dive into the MIT-licensed project at docs.neuroca.dev for a deep memory experience.

Tags: AI, memory system, organic, MIT license, self-maintenance

Power Up Your Mac Workflow with AI-Powered Apps

Discover top MacOS apps enhanced with APIs from openAI and more for boosted productivity. Users recommend Kerlig for quick actions, Chatwise for MCP support, and RewriteBar as a cost-effective alternative to Kerlig.

Tags: MacOS, apps, AI, Kerlig, Chatwise, RewriteBar

Get ready to dive into a lineup that's all about power and liberation. From unleashing offline sync capabilities with Turso to exploring Nue's Rust-powered web dev revolution, this roundup is for tech rebels looking to break free from constraints. OpenAI's tease of a new language model and a concise list of MCP servers add the perfect mix of innovation and practicality for developers, designers, and AI enthusiasts. Buckle up for a ride through the latest in tech evolution and discovery.

Turso Offline Sync: Unleash Offline Capabilities Now!

Discover the power of Turso Offline Sync in public beta! Seamlessly sync local databases with Turso Cloud, enabling fast, offline-capable applications for mobile, IoT, and more. Explore bi-directional sync, remote write support, and simplified use cases.

Tags: Turso, Offline Sync, Public Beta, Local Databases, Mobile Apps, IoT

Nue: Lighter Apps, Liberated Engineers, Joyful Web Dev

Discover Nue's cutting-edge approach to web development with Rust computation, Event Sourcing, and immediate feedback tools. Engineers break free from React constraints, design engineers simplify systems, and UX engineers elevate user experiences with ultra-light applications. Uncover the revolution in web standards and cleaner architectures with Nue.

Tags: Nue, web development, Rust, Event Sourcing, design, UX, React

OpenAI Teases Release of New Open Language Model

OpenAI hints at launching a new 'open' language model, seeking input from developers and researchers. Facing competition from 'open' model rivals, OpenAI plans to host developer events worldwide to gather feedback and demo prototypes.

Tags: OpenAI, language model, developers, researchers, AI, competition

Concise List for MCP Servers: Awesome Finds

Discover a curated list of MCP servers spanning browser control, art, cloud platforms, command line, and communication. Dive into innovative projects integrating AI, web browsing, cloud services, and more. Stay updated with this continuously evolving and star-worthy repository.

Tags: MCP servers, browser control, art, cloud platforms, command line, communication

Get ready to level up your tech game with this week's 'Tabs Still Open' roundup. Anthropic's Claude 3.7 Sonnet upgrade promises a 500K token power surge, challenging data processing norms. Bytedance is sparking a coding revolution on TikTok, diving into programming and tech innovations. Explore how participatory design in Norway is transforming communities and visual identities. Plus, craft your own macOS status bar experience with SketchyBar's highly customizable features. Tech enthusiasts, coders, designers, and macOS users, these links are for you!

Anthropic's Claude 3.7 Upgrade: 500K Token Power Surge

Anthropic teases a massive boost to Claude 3.7 Sonnet with a jaw-dropping 500K token context window, aiming to revolutionize data processing and coding workflows. The upgrade hints at game-changing potential in processing huge datasets and codebases, challenging conventional context limitations and paving the way for vibe coding's rise.

Tags: Anthropic, Claude 3.7, AI, data processing, coding, vibe coding, technology

Bytedance's Coding Revolution on TikTok

Discover how Bytedance is shaking up coding on TikTok with innovative content. Dive into programming, tech, and more. #coding #programming #tech

Tags: coding, programming, tech, Bytedance, TikTok

Transforming Communities with Participatory Design in Norway

Explore how Kulturhavn in Norway uses participatory design to reshape community spaces, merging visual identity and user input. Dive into brand design, graphic design, and community engagement strategies.

Tags: participatory design, brand design, graphic design, community, branding, cultural spaces, Norway

SketchyBar: Highly Customizable macOS Status Bar Replacement

Create a customizable macOS status bar replacement with dynamic animation, powerful scripting, efficient performance, mouse support, and more. Easily configure elements dynamically with an event-driven scripting system. Explore installation and customization options to personalize your status bar experience.

Tags: macOS, status bar, customization, scripting, efficiency, installation, configuration

ChatGPT 4.5 just dropped as the new preview release, promising better deep research and creative content generation. So, I put it to the test - alongside 4o. I asked both models the exact same thing:

“Write a story about the open-source app Nomie by Brandon Corbin.”

No extra context. No special prompts. Just that. Safe to say… 4o absolutely killed it. Check out the results and tell me what you think. Who’s the real winner here?

4.5

Nomie began in 2014 as an experiment by Brandon Corbin, a designer and developer who loved tinkering with personal data but was frustrated by existing life-tracking apps. Brandon envisioned a personal, intuitive tracker—one without the clutter, complexity, or invasive practices of traditional apps.

Originally launched under his creative entity, Happy Data, Nomie aimed to empower users to privately track aspects of their lives—from moods and habits to health and productivity metrics. Unlike other apps hungry for data, Nomie championed privacy: your data belonged to you, stored locally or synced securely only if you chose.

As Nomie evolved, Brandon released it fully open source in 2019, inviting the community to collaborate, adapt, and expand its capabilities. This decision made Nomie not just an app, but a movement—users now had the freedom to customize and extend it according to their unique needs, spawning a passionate, diverse community.

Despite its loyal following, Nomie faced challenges. Maintaining and supporting an open-source project required effort, but its community grew, sharing modifications, supporting one another, and keeping the original vision alive: user-owned data, private tracking, and tools that genuinely helped people understand themselves better.

Nomie still lives on today as a symbol of Brandon’s vision for technology that respects its users, proving that design can be human-centered without sacrificing privacy or usability.

4o

Alright, let’s talk about Nomie—the open-source life tracker that came straight from the mind of Brandon Corbin.

The Birth of Nomie (2014)

Back in 2014, Brandon launched Nomie under Happy Data. It started as a simple but powerful life-tracking app designed for people who wanted to collect and analyze their own data without handing it over to big corporations. The idea was that you should be able to track anything—moods, habits, medications, workouts, caffeine intake—without your data being stored on some random server where it could be exploited.

At its core, Nomie was built on privacy, simplicity, and flexibility. It wasn’t just about tracking for the sake of it; it was about helping people identify patterns, improve their lives, and make decisions based on real personal data.

The Nomie Experience

Nomie allowed users to create custom trackers for anything they wanted. Feeling stressed? Tap a button. Drank a coffee? Log it. Over time, this data turned into insights—trends, correlations, and a better understanding of what was driving behaviors.

Unlike other tracking apps that required sign-ups and stored everything in the cloud, Nomie was built to be completely private. Users could store their data locally or on their own storage solutions, like CouchDB, which was pretty rare for an app of its kind. It was about your data being yours—not locked behind some subscription or analytics-driven business model.

The Open-Source Evolution

Brandon made Nomie open source, which meant anyone could tweak, improve, or even self-host it. This move reinforced the idea that life tracking should be for the people, by the people, not another avenue for corporate data mining.

As an open-source project, Nomie gained a loyal community of users who appreciated its privacy-first approach. It became one of the first real life tracker applications that wasn’t tied to a walled garden, attracting indie developers, quantified-self enthusiasts, and privacy advocates.

The Challenges & The Sunset

Of course, as with any independent project, keeping Nomie running and evolving was a massive undertaking. While people loved it, life tracking isn’t exactly a cash cow, and maintaining an app—especially one as flexible and feature-rich as Nomie—takes time and effort.

At some point, it became clear that continuing to develop Nomie at scale wasn’t sustainable. Eventually, Brandon had to step away from active development, but not before leaving behind a powerful open-source foundation that people could still build on.

The Legacy of Nomie

Even though Nomie is no longer actively developed, its DNA lives on. The core ideas—privacy-first tracking, full control over personal data, and user-driven customization—are still influencing other tracking apps today.

For Brandon, Nomie was more than just an app. It was an experiment in giving people the tools to understand themselves better without selling their data in the process. It was ahead of its time, offering something that mainstream apps still struggle to deliver—a truly user-controlled experience.

Would Nomie make a comeback? Who knows. But one thing’s for sure: it left a mark on the quantified-self space and showed that life tracking can be personal, private, and open.

So who won?

But developers who use AI will replace developers who don't

I needed a simple service that takes a bunch of URLs, scrapes the content, and spits it out as a single Markdown file. Sounds easy enough. I was building a custom GPT for The Big Cheese AI Podcast and needed a way to quickly extract meaningful headlines from various news sources. So I thought, "Let’s build a quick and dirty Deno project with Cursor AI to do just that!" and while I'm at it "Let’s record it!"

What followed was an adventure in frustration, laughter, and a whole lot of cursing.

Step 1: The Setup (Before the Screaming Started)

I started up fresh Deno project, ready to roll. First step - create a server that:

1. Takes a list of URLs.
2. Fetches the raw HTML.
3. Strips out all the useless crap (styles, JavaScript, tracking pixels).
4. Converts the cleaned content into Markdown.
5. Returns a single Markdown file containing everything.

Sounds like a solid plan. But plans and reality rarely get along.

Step 2: Enter Cursor AI - The Junior Dev from Hell

If you haven’t used Cursor AI before, let me explain: imagine an overeager junior developer who gets most things right but occasionally decides to rewrite your entire function because it thought you wanted something different.

So I start feeding Cursor my requirements, and then…

Step 3: AI, Stop Gaslighting Me

The moment I hit “run,” things took a turn.

• It spits out an error.
• I fix it.
• It suggests something I literally just told it to do.
• I fix that too.
• It apologizes
• It spits out another error.

And this cycle just keeps going.

At one point, I had to literally tell it, “Stop recommending to fucking run the Deno command! We have a watch process!” But no - Cursor just had to keep telling me to manually restart things.

Then came the ultimate betrayal:

It wrote a function.
It forgot it wrote the function.
It asked me if I wanted to write that function.

I lost my damn mind.

Step 4: Debugging Like a Caveman

At this point, the service was half-working. It was fetching URLs, but the Markdown was a mess. So I did what any sane developer does when AI keeps failing - I copied errors into Cursor and screamed at it to fix its own mess.

The funniest part? It started matching my energy.

• I yell: “You [___] idiot! Strip out the JavaScript first!”
• Cursor: “Oh [___], I see the issue. Let me clean that up.”
• I yell: “No, that’s still wrong, you useless [___]!”
• Cursor: “Oops, sorry, totally [___] that up. Here’s a fix.”

I swear, AI is developing Stockholm Syndrome at this point.

Step 5: Victory... Kind Of

After fighting and fighting, the Markdown finally looked right. Cursor had stopped gaslighting me (mostly), and I had a working Deno service. It wasn’t pretty, but it did the job:

1. Take a list of URLs.
2. Scrape the useful content.
3. Strip out all the tracking junk.
4. Convert to Markdown.
5. Return it in a single, beautiful, AI-readable file.

I threw in some quick refinements, tested it with a few URLs, and BAM - success. The damn thing worked.

Final Thoughts: AI Is Useful, but It’s Also a Troll

Look, I love AI. It speeds up my workflow like crazy. But it’s also like that intern who needs constant babysitting. You can’t trust it blindly, and you will need to yell at it from time to time.

Would I use Cursor AI again? Absolutely.
Would I scream at it the entire time? Also yes.

Moral of the story? AI coding assistants are great - just don’t expect them to actually listen to you.

Now if you’ll excuse me, I need a drink.

Alright, let’s get straight into it. I built a native iOS application using AI – and it was an absolute disaster. But before we get into the nitty-gritty of why this entire ordeal had me flipping tables and questioning my life choices, let’s address the elephant in the room. People are out here screaming from their rooftops that AI is going to replace developers. I’m here to tell you that’s bullshit. If anything, AI has made it crystal clear that senior developers are safe, junior developers are on the chopping block, and everyone else better buckle up because it’s a bumpy ride.

The Problem That Started It All

Picture this. My car needed some work – recall situation. I go to get a loaner, and the guy asks for my insurance. No problem, right? Wrong. I left my wallet at home. Thankfully, I knew I had a photo of my insurance card somewhere in the abyss that is my camera roll. I started scrolling, searching, and swiping like a maniac until I finally found it. That’s when it hit me – this is a god-awful way to organize important documents.

So I had this genius idea: what if I made an app where I could just take photos of my documents, organize them neatly, and have them instantly accessible? Maybe even import PDFs or sync it all across my devices. Boom – idea born. And because I’m a masochist, I decided to build it as a completely native iOS app. Oh, and let’s let AI do all the heavy lifting. What could go wrong?

The First Attempt: Show Me Your Papers (Horrible Name, I Know)

I fire up Xcode, start a new project, and name it "Show Me Your Papers" – a name so bad, I’m embarrassed to even type it. Then I open Cursor, my AI co-buddy, and feed it a list of requirements. I tell Cursor what I want the app to do, and it starts generating files and writing code like it’s auditioning for "America’s Got Talent."

Here’s how it went:

1. Cursor writes some code.
2. I run the app.
3. Errors. Copy errors. Paste errors into Cursor.
4. Repeat.

I quickly realized I wasn’t a developer anymore – I was an orchestrator. The AI was my chaotic little intern, and I was its stressed-out manager. At first, it was magical. I even went on LinkedIn to preach about how this was the future of development. But then I hit a wall. I needed data to sync across devices, and Cursor decided to use Core Data – Apple’s clunky, outdated data storage framework. Migrating to Swift Data (the newer, better option) turned the entire project into a flaming dumpster fire. After two days of fighting errors, I flipped my desk and walked away.

Attempt Two: The Pink Binder Disaster

Determined to make this work, I started fresh. This time, I renamed the app "Pink Binder," inspired by a friend who kept her parents’ important documents in a literal pink binder. The name felt right, and I thought maybe a clean slate would solve all my problems.

I asked Cursor to generate a massive document with all the app’s requirements, features, and data models. Then I fed it back into Cursor and told it to build the app. It started cranking out files and creating a directory structure that actually looked decent. I thought, "Alright, maybe this time it’ll work."

Spoiler: It didn’t.

For three straight days, I played the same game. Run the app. Errors. Copy. Paste. Fix. Repeat. Three. Damn. Days. The app never ran on my device. Not once. By the end, I was so furious I almost threw my MacBook out the window.

The Final Attempt: Paper Keeper

By now, I was battle-hardened and ready for war. I started over again, this time with a clearer plan. The app was now called "Paper Keeper," and I approached it differently. Instead of letting Cursor run wild, I took control. I defined all the features, laid out the directory structure, and even created stub files with comments explaining what each part of the app was supposed to do. Then I let Cursor build small pieces, one step at a time.

This process was tedious as hell. I had to babysit the AI, correct its mistakes, and constantly remind it to stay within the lines. But it worked. After weeks of pain and suffering, I finally had a working app. Paper Keeper was alive, and it was actually pretty awesome.

What I Learned

Here’s the cold, hard truth: AI isn’t ready to replace developers. Not even close. It’s a tool, and if you don’t know how to use it, it’ll burn you. AI can replace junior developers because it’s great at handling repetitive, straightforward tasks. But here’s the problem – where do senior developers come from? They start as juniors. If we cut off that pipeline, we’re screwed in the long run.

For now, AI is a powerful assistant. It can help you build faster and make your life easier, but it’s not a magic wand. If you’re not a developer and think AI will let you build a killer app solo, good luck. You’ll either end up with a half-baked app or a full-blown mental breakdown.

How to Use Get It

Paper Keeper is live and ready for action. It’s an iOS app that keeps your important documents organized, secure, and instantly accessible. If you’re tired of digging through your camera roll for insurance cards or warranty PDFs, check it out at paperkeeper.app or install it from the AppStore

As for AI? Use it. Embrace it. But don’t let it fool you into thinking it’s the second coming of developer Jesus. We’re not there yet – and we probably won’t be for a while.

How many project have you been on where developers and designers seemed to be speaking different languages? It’s way too common for these two crucial teams to be working in silos, leading to miscommunication, delays, and a product that doesn’t quite hit the mark. But it doesn’t have to be that way.

Breaking down these silos is a practical step toward better products, happier teams, and smoother processes. Let’s dive into how developers and designers can work better together.

The Cost of Working in Silos

When developers and designers stay in their separate bubbles, things can go sideways pretty quickly. Maybe the design team hands off a mockup that’s missing key elements, or the developers implement something that doesn’t match the intended user experience. The result? Misaligned designs, last-minute changes, and frustration all around.

This doesn’t just impact the teams - it affects the final product. Poor UX/UI quality, extended timelines, and higher costs become the norm. And let’s face it, an “us vs. them” mentality helps no one.

Understanding Each Other’s Roles

What Developers Wish Designers Knew

• Design Decisions Have Technical Implications: That cool animation or intricate layout might look fantastic, but it could be a challenge to implement efficiently. Developers appreciate when designers consider the technical side of things.
• “Just Make It Work” Isn’t Always Realistic: Constraints like browser compatibility, performance issues, and existing tech stacks can limit what’s possible. Open dialogue about these constraints helps set realistic expectations.
• Clear, Complete Designs Are Essential: Missing responsive layouts, personas, or accessibility considerations make development harder and can lead to guesswork. The more detailed the design, the smoother the build.

What Designers Wish Developers Knew

• Designs Are Carefully Crafted: Every element has a purpose. They’re not just suggestions but are based on user research and best practices. Skipping or altering them can diminish the user experience.
• Micro-Interactions Matter: Those subtle animations and transitions enhance the product’s feel. Ignoring them can make the interface seem flat or unpolished.
• Ask Questions Early: If something isn’t clear, bringing it up sooner prevents bigger issues down the line. Designers appreciate proactive communication.

Building Bridges Between Developers and Designers

1. Start with Shared Goals

Kick off projects by aligning on the purpose and objectives. Use user stories to create a shared contract that everyone agrees on. This ensures both teams are on the same page from day one.

2. Encourage Regular Collaboration

Hold cross-functional meetings and design reviews. Regular check-ins prevent surprises later on. Use shared tools like Figma to allow developers to provide early feedback on designs.

3. Clarify Roles and Expectations

Define who is responsible for what. Who handles micro-interactions? Who writes error states? Documenting this avoids confusion and overlaps.

4. Establish a Feedback Loop

Create channels for continuous feedback during and after development. Encourage mutual respect and constructive criticism. Remember, you’re all working toward the same goal.

Practical Tips for Collaboration

For Developers

• Ask Questions Early and Often: Don’t wait until the last minute to clarify uncertainties. It’s better to over-communicate than to assume.
• Push Back When Necessary: If designs lack critical details like responsive views or realistic placeholder content, speak up. It’s not about being difficult - it’s about ensuring the best possible product.
• Use Design Systems: Staying consistent with established design guidelines helps maintain a cohesive product and speeds up development.

For Designers

• Provide Clear Documentation: Ensure that handoffs include all necessary details, from assets to specifications. The more information, the better.
• Consider Technical Constraints: Collaborate with developers to understand what’s feasible. This doesn’t mean limiting creativity but finding the best way to bring ideas to life.
• Stay Involved During Development: Regular check-ins help ensure the vision is executed properly and allows for adjustments if needed.

Tools and Practices That Bring Teams Together

• Use Collaborative Tools: Platforms like Figma, Notion, or shared Slack channels promote transparency and make it easy to share updates.
• Document Processes Centrally: Keep guidelines, assets, and documentation in a place everyone can access. This reduces misunderstandings and saves time.
• Pair Up for Complex Features: Sometimes, designer-developer duo sessions can iron out tricky parts more effectively than back-and-forth messages.

Breaking Down Silos for the Long Term

• Foster a Culture of Collaboration: Make cross-functional teamwork the norm, not the exception. Encourage team members to share ideas and feedback openly.
• Celebrate Wins Together: Acknowledge contributions from both teams when you hit milestones. This builds camaraderie and mutual respec
• Invest in Team-Building: Activities outside of work can strengthen relationships and improve collaboration. Whether it’s a team lunch or a workshop, these experiences pay off.

Conclusion

Breaking down silos between developers and designers isn’t just good for team morale - it’s essential for creating products that truly shine. By understanding each other’s roles, fostering open communication, and collaborating regularly, we can build better experiences for everyone involved.

Why not try one new collaboration tip in your next project? You might be surprised at the difference it makes. And hey, if you’ve got your own stories or tips, I’d love to hear them. Let’s keep working together to make awesome things happen.

If you’ve ever tried juggling multiple clients and projects while running a business, you’ve experienced the same hell I’ve faced trying to track your time.

I run a product design studio, and while I thrive on the ADHD-friendly chaos of hopping between clients, the idea of meticulously logging every minute of my work? Uh, no. I just wanna do my work.

Here’s the problem: every time-tracking platform I’ve tried has been .. well, horrible. They’re clunky, require too much executive function, and ultimately I never actually use them. And what’s the golden rule? The best products are the ones we actually use. So I ditched the apps and decided to do what I normally do, and try to build off something I already rely on: my Notion todo list.

Why Traditional Time Tracking Doesn’t Work for Me

Time tracking has always been a pain in the ass.. As someone with ADHD, I tend to hyperfocus on the work itself and forget about things like starting and stopping timers. Plus, with multiple clients and projects on my plate, switching gears is part of the deal. I don’t want to interrupt my flow just to update some overly complex time tracker.

This year, my system (or lack thereof) finally bit me in the ass. During my December review- when I force myself to look at my finances - I realized I’d spent an absurd amount of time on a fixed-bid project. That passion project gobbled up so much of my time that my hourly work suffered. In short, I left a ton of money on the table because I had no clear view of how my time was actually being spent.

Something had to change.

My Notion Todo List

Here’s the thing: I already have a super-organized system in Notion. Every day, I break down tasks by client in a running todo list. Each month, I start a fresh page, and I’ve been doing this for over two years now. It’s simple, it works, and most importantly, I actually use it.

So instead of adding yet another app to my life, I decided to build on what I was already doing.

How I Turned My Todo List into a Time-Tracking System

The beauty of this system is its simplicity. I didn’t want to overhaul my entire workflow - just enhance it. The only thing I added to my todo list was the time spent on each task, and I kept it as flexible as possible because since labeling consistency isn’t my strong suit.

Here’s what it looks like in practice:

• [x] Do this one thing (1.4hr)
• [x] Did that other thing (14min)
• [x] Followed up on that thing (4m)

It doesn’t matter if I use “hr,” “min,” or random abbreviations like “m.” The goal was to capture the essence of time spent without overthinking it. Same with the dates, I am totally inconsistent with how I label dates, so the system can account for virtually any permutation.

Automating the Hard Part

Once I had a few months of this data, I realized I could automate the rest. I fired up Cursor (a killer AI coding assistant) and wrote a script to parse my Notion todos. It does a few key things:

1. Extracts tasks, durations, and clients from my lists.
2. Converts the time formats into a consistent structure.
3. Generates a timesheet with a breakdown of time spent by client and project.
4. Calculates costs, so I can see exactly how much I’m earning—or losing—on fixed-bid work.

Now, at the end of each month, I can hit a local website and get a great summary of my time (sure it takes 15 seconds to render because the Notion API is created by insane people, but it's absolutely invaluable). I then made it stupidly easy to copy into InvoiceNinja, the app I use for billing clients.

The Results? Clarity and Control

Here’s what this new system has done for me:

• Visibility: I can instantly see where my time is going and how much each client costs me.
• Profitability Insights: I can tell at a glance if fixed-bid projects are worth it or if I’m overcommitting.
• Easier Invoicing: Since everything is broken down by client, invoicing takes minutes, not hours.

Next on my to-do list? Adding the ability to push these timesheets into InvoiceNinja to automatically generate my invoices.

TIL: Time tracking doesn’t have to suck.

By integrating it into a system I already loved, I turned what used to be a frustrating chore into a seamless part of my daily routine. Best of all, I can finally make informed decisions about my work—and my bottom line.

If you’ve been struggling with time tracking, consider this your permission to ditch the clunky apps and make something that works for you. You don’t need fancy software—just a little creativity and a system you’ll actually stick with.

Your Turn: Do you have a favorite Notion hack or time-tracking tip? Share it in the comments—I’m always looking for better ways to work smarter, not harder.

For the last 20+ years, I’ve been balls-deep in code. Front-end, back-end, full-stack - you name it, I’ve probably wrestled with it. From the wild-west days of Backbone and jQuery to the modern landscapes of Angular 1&2, React (next, native and create), Vue, Svelte, and even a sprinkling of Rust, I’ve built apps that would make even the most seasoned developer groan at their complexity. These weren’t just toy "Hello World" projects or half-assed Todo apps. I’m talking full-blown, overbuilt monstrosities packed with features no one asked for but some stakeholder insisted on.

I’ve paid my dues. I’ve struggled through Perl scripts that felt like a personal insult, wrestled with PHP spaghetti, and chased down bugs that made me question my life choices. And for the most part, I loved it - except when I didn’t.

But last month, I started paying for Cursor - and holy shit, it’s like I’ve stepped into a cheat code for coding.

Why Cursor Changed Everything

Cursor isn’t just another code editor. It’s not just a glorified VS Code Plugin. It’s a game-changer, a secret weapon, a damn lifesaver for someone like me who’s battled dyslexia, ADHD, and a million tabs of Stack Overflow open at once.

Here’s what Cursor has done for me:

1. I’m Not Afraid Anymore

For years, there were parts of coding that intimidated the hell out of me. Not because I didn’t know how to learn them, but because the learning curve felt like staring up at Everest. Writing complex Rust tools? A pipe dream. Debugging some cryptic error that’s been staring me in the face for days? Pure hell.

But with Cursor, I’m not just "capable" - I’m fearless. It helps me break down problems, suggests solutions, and keeps me moving forward. There’s no more getting stuck in the weeds for days because my dyslexic brain couldn’t parse something obvious.

2. Bugs Don’t Stand a Chance

You know those bugs that make you want to throw your shit out the window? The ones where your code should work, but it doesn’t? And after hours of Googling, it turns out you missed a semicolon or used a single equals instead of a double? Yeah, those don’t stand a chance with Cursor.

It’s like having pair programmer who's WAY more observant than you. Cursor spots the shit I miss and even explains why it’s wrong. It’s like having an insanely smart buddy (albeit a bit socially awkward) who doesn’t judge you for stupid mistakes.

3. It Makes Me Faster

I’ve always prided myself on being a fast coder. But Cursor? Cursor makes me feel like I’m in goddamn super hero. Need to spin up a new feature? Done. Need to refactor a gnarly section of legacy code? No problem. Need to write unit tests (because, yes, I actually write those now)? Cursor’s got me covered.

It’s not just about speed, though. It’s about quality. I’m producing better code in less time because I’m not bogged down by minutiae or paralyzed by analysis paralysis. All this said, a non-coder would be fucked in this world. They'd never know how to get out of the loops, or help Cursor identify what's actually going on - which in some ways is even more frustrating than that phantom bug you've been hunting for months.

Superpowers for Developers

Let me be clear: tools like Cursor aren’t here to replace developers. If you’re worried about that, stop. Take a deep breath. These tools aren’t coming for your job - they’re giving you superpowers.

Think about what this means for the future:

• Creativity unlocked: We’ll be able to build things faster and better than ever before. That side project you’ve been dreaming about? It’s now a weekend project, not a year-long grind.
• Barriers obliterated: Complex languages like Rust or obscure frameworks won’t scare you anymore. The learning curve is still there, but you’ve got a jetpack strapped to your back.
• Collaboration elevated: Less time wasted on bullshit bugs means more time spent on innovation and problem-solving.

This isn’t about replacing devs; it’s about empowering us to do the work we’re passionate about without the tedious roadblocks.

The Reality Check

Let’s not sugarcoat it: if you’re a junior developer, these tools won’t make up for a lack of foundational knowledge. You still need to understand how code works, why design patterns matter, and how to think critically about solving problems. But once you’ve got those basics down, tools like Cursor are like giving a marathon runner a jetpack.

For those of us who’ve been in the game for years? It’s like seeing color for the first time.

My Prediction

The amount of stuff we’re going to be able to crank out in the next five years is going to be insane. Products that once took entire teams months to build will now take a single dev a few weeks. The landscape is shifting, and if you’re not using tools like Cursor, you’re going to get left behind.

But the best part? It’s not just about efficiency - it’s about joy. For the first time in a long time, I’m excited about coding again. Cursor has reminded me why I fell in love with this work in the first place.

So yeah, I can no longer code without Cursor - and honestly, I’m cool with that.

What about you? Have you tried Cursor or another AI-powered coding tool? I’d love to hear your thoughts. Drop a comment or hit me up on BlueSky.

Startups are a minefield of uncertainty. You’ve got limited resources, big dreams, and a million fires that need putting out yesterday. In the middle of all this chaos, there’s one thing that will absolutely make or break your ability to build something great: brutal honesty. Not “honesty,” not “constructive feedback,” but the brutal, unvarnished fucking truth. The kind of truth that stings in the moment but saves your ass long-term.

The Hard Truth Is Better Than a Comfortable Lie

In this phase of creation, every single decision matters. Even the tiny ones - the “do we ship this half-baked feature or wait another week?” kind of calls. When the truth gets fudged even a little, it creates ripple effects that can derail an entire project.

Here’s an example: Imagine someone on your team says, “Yeah, the prototype is basically ready to go,” when it’s actually a buggy clusterfuck held together by duct tape, nicotine, caffeine and prayers. Maybe they didn’t want to disappoint anyone. Maybe they thought they could fix it in time. Either way, now your marketing team is hyping up a launch that’s going to absolutely crash and burn - all because someone wasn’t honest enough to say, “This thing isn’t ready, and here’s why.”

The lesson? You can work with the truth, no matter how ugly it is. But a lie - even a small one - will kill you. Lies rob you of the chance to address problems head-on, and in a startup, those missed chances can be fatal.

Why People Avoid Brutal Honesty (and How to Fix It)

Let’s be real: brutal honesty is uncomfortable as hell. Nobody wants to be the one to say, “Hey, this design sucks,” or “Your idea doesn’t make sense.” And nobody wants to hear it, either. Our brains are wired to avoid conflict, especially in high-pressure environments where everyone’s just trying to keep the wheels from falling off.

But here’s the thing - avoiding conflict doesn’t actually reduce conflict. It just buries it until it explodes in your face. A bad idea that goes unchallenged today turns into a massive waste of time and money tomorrow. A teammate who’s not pulling their weight now becomes a full-blown liability later.

The fix? Build a culture where brutal honesty is expected. Here’s how:

1. Lead by Example: If you’re the founder or team leader, you set the tone. Be the first to call out problems and admit when something’s not working. When people see you owning your mistakes, they’ll feel safer owning theirs.
2. Normalize Feedback: Make regular, no-bullshit feedback part of your process. Hold retrospectives after sprints, and don’t just focus on the good stuff. Ask, “What went wrong? What could we have done better?”
3. Remove Ego from the Equation: It’s not about you - it’s about the work. Frame feedback around the problem, not the person. “This strategy isn’t working” is a lot easier to hear than “You’re screwing everything up.”
4. Celebrate the Fix, Not the Fault: When someone points out a problem, don’t make them feel like they’re the bad guy. Celebrate the fact that they had the guts to speak up. The faster you spot issues, the faster you can solve them.

Brutal Honesty Builds Trust (and Teams That Actually Work)

Here’s the paradox: brutal honesty, when done right, actually makes your team stronger. Why? Because it builds trust.

When you know your teammates will tell you the truth - even when it’s hard - you stop wasting energy second-guessing them. You stop playing political games. You start focusing on what actually matters: building something awesome together.

And trust me, when everyone’s on the same page, shit gets done. No more tiptoeing around problems. No more “everything’s fine” when it’s clearly not. Just a team that’s aligned, focused, and ready to haul ass.

The Takeaway: Just Be Honest.

Brutal honesty isn’t just a “nice to have” in a startup - it’s a necessity. It’s the foundation for trust, efficiency, and actually getting things done. The sooner you and your team get comfortable with it, the sooner you can stop spinning your wheels and start making real progress.

So, the next time you’re tempted to sugarcoat the truth or let something slide, ask yourself: “Is this helping, or is this hurting?” Because in the end, the truth - no matter how brutal - is always better than the alternative.

And hey, if you need someone to tell you your 👶 baby’s ugly, hit me up. I’ve got a knack for cutting through the nonsense.

This week was a whirlwind of AI, new tools, and even a dive into tax preparation using a locally ran large language model. Here’s what I’ve been working on, learning, and building over the last week.

Happy Data AI Tools

I kicked off the week by publishing happydata-ai, a small yet powerful set of utilities I rely on for nearly every AI-driven project. It’s designed for OpenAI-compliant endpoints and Ollama, with features like forced JSON output using Zod Schemas, variable prompts, PII redaction, and more.

Should you use it? Honestly, I’m not sure—but I do, and it makes my life easier. Check it out if you’re diving into AI integrations.

Got on BlueSky

I finally decided to leave the madness of the platform formerly known as Twitter for BlueSky, and let me tell you—it’s a breath of fresh air. No echo chambers, just meaningful connections. If you’re there, let’s connect: brandons.app.

Prepping for Taxes with AI

Yes, you read that right: I’m tackling tax prep with AI. I started building a tool using Bun and Ollama to run Llama 3.2-instruct locally on my Mac, ensuring nothing private goes over to OpenAI.

Here’s the process so far:

1. Search Gmail for receipts, invoices, and POs.
2. Extract attachments and HTML emails, then convert everything to Markdown.
3. Pass the Markdown and my Zod Schema to Llama 3.2 to generate JSON payloads breaking down each item.

So far, it’s working! Next week, I plan to convert the JSON data into a SQLite database, where I’ll query and manage it using a tool I built a few weeks back.

InfoCap AI Seminar

This week, I flew to Atlanta to attend InfoCap’s AGENTIC AI + Decision Intelligence seminar. It was a small but impactful event, even if a bit of a soft ad for InfoCap.

I walked away with some fresh ideas, particularly around Directed Acyclic Graphs (DAGs) and the OODA loop (Observe, Orient, Decide, Act). These concepts are already influencing how I approach problem-solving and decision-making in my projects.

Persona Generation Adventure

About six months ago, a major client asked me to generate customer personas based on their data. After a five-month wait, I finally received a dataset… but couldn’t confirm who the data represented. I ran the process, generated personas, and prepped for a leadership pitch.

Then, my boss asked, “Can you confirm where this data came from?” (Pro tip: Always do this first!) Turns out, the dataset contained 70,000 non-profit members, most of whom were not customers.

I reworked the pitch, showcasing the methodology, but made it clear we needed real customer data. Shortly after, I gained access to 400,000 actual customer records and delivered a polished set of personas that resonated with the leadership team. Lesson learned!

Looking Ahead

From launching AI tools to exploring new platforms and applying decision intelligence frameworks, this week has been equal parts challenging and inspiring. Next week, I’ll be diving deeper into the tax tool, refining personas, and exploring even more creative AI applications.

Let me know what you think of these projects—or better yet, share what you’re working on. Let's build something amazing!

Saying Yes to Myself

For most of my life, I’ve operated by a simple motto: “start with yes.” It’s been my guiding principle, shaping the way I approach opportunities, relationships, and even challenges. It’s made life improvisational, spontaneous, and adventurous - qualities that have brought me countless memories, projects, and connections I wouldn’t trade for anything.

However recently, I’ve been reflecting on what saying “yes” has actually cost me over the years.

When I was younger, “start with yes” felt like the right mindset. It was about exploring the world, chasing ideas, and seeing where the current would take me. But as I've gotten older, I’ve noticed how easy it is for that motto to pull me away from the things that truly matter to me. Opportunities can be enticing, distractions can masquerade as growth, and before I know it, I’m pouring my energy into things that aren’t aligned with my own journey.

It’s not always easy to recognize when it’s happening, but the effects are clear: I’ve often focused more on saying yes to the world around me than on saying yes to myself.

The Shift: From “Yes” to What Matters

In 2025, I’m making a change. Instead of starting with yes, I’m adopting a new motto: If it’s not a “hell yes,” it’s a no.

This isn’t just about being selective—it’s about being intentional. It’s about honoring my time, my energy, and my purpose. The things I say yes to should excite me, inspire me, and move me forward. If they don’t? They’ll need to wait for someone else’s “yes.”

This shift feels necessary. I’ve spent so much of my life trying to be too many things to too many people, leaving less and less for myself. That’s not sustainable, and frankly, it’s not fair to me - or to the things and people I genuinely care about.

Why This Matters

Saying no can be hard, especially when you’re someone who thrives on creativity, collaboration, and the thrill of the new. But I’ve realized that every “yes” carries a cost. It’s not just time - it’s focus, attention, and emotional bandwidth. By saying yes to the wrong things, I’ve been saying no to the projects, ideas, and people who deserve my best self.

For me, 2025 is about reclaiming my energy. It’s about focusing on what matters most—whether that’s diving into exciting projects, spending quality time with my family, or even just taking the time to breathe and reflect.

What’s Next

I’m not giving up on being open-minded, or curious - those qualities are simply too much integrated in to my being. But I’m learning that boundaries aren’t limits; they’re guideposts. They help us move forward with clarity and purpose.

So, here’s to 2025: the year of the “hell yes.” If it’s not something that lights me up, aligns with my values, and moves me closer to my goals, it’s a no.

I’m looking forward to seeing what this new mindset unlocks. And if you’re someone who’s struggled with balancing openness and focus, maybe this motto will resonate with you too.

After all, life’s too short for half-hearted “yeses.” Let’s save our energy for the things that truly deserve it.

What’s your motto for 2025?

I'm not motivated by money. Sure, I like it. I need it. But it's never been what gets me up in the morning. Even now, I'm in the top 90% of earners in the United States, and yet I still hate making it. It's not that I dislike having money; I love the freedom it provides. I just can't stand the part where you have to chase it. The thought of clawing for every dollar or negotiating every deal down to the last cent doesn't fill me with energy—it drains me.

This lack of motivation to fight for money goes way back. When I was a a wee lad, I was hanging out with a group of friends, and one of them threw a couple of dollars on the ground—I think it was three or four crumpled bills, nothing major. But what happened next was pure madness. My friends lunged for those bills like their lives depended on it. It turned into a real-life Lord of the Flies. Bodies scrambling, tripping over each other, all for a few bucks. And there I was standing there watching the chaos unfold. I remember thinking, "I don’t have that in me." I didn't want it that badly That was the first time I realized that I don’t have that natural instinct to fight for money.

Fast forward to today, and not much has changed. I still don't have that fight. The amount of hours I’ve worked for clients without billing them—well, let’s just say it would make my wife weep. It’s not that I’m unaware of my value or that I think my time is worth less. It’s that I genuinely love what I do. I love the problems my clients bring to me. I love the thrill of diving in headfirst and working through challenges, the satisfaction of cracking something wide open that seemed impossible. I love the work. And because I love it, money always seems like an afterthought. I get into the flow, solve problems, make things happen—and then I forget to care about the invoice.

I’m fortunate, for sure. My family doesn’t have to worry too much about money. We’re good—except, of course, when Tax Day comes around, and I realize I’ve been a little too generous with my time.

Last year, I took on a new client that I absolutely love working with. They’re fantastic—passionate, interesting, doing work that is genuinely the most interesting I've ever work with. When we first started, I quoted them 10 to 15 hours per week. But here’s the thing: I don’t do well with keeping track of hours. If I’m motivated by the work, I’ll work however long it takes to get the task at hand done. I won’t cut myself off because I hit some arbitrary limit. I just do the work because, honestly, I want to see it finished, and I want to see it done well.

And so, week after week, this 10 to 15 hours ends up being more like 20, then 25, then 30 hours some weeks. I just kept telling myself "It's fine, I'll make it up later," or "This is just what is needed right now."

But then as the end of the year nears, and I had to face the numbers. I had to look at what I’d actually billed versus what I’d actually worked. I left a lot of money on the table this year. I loved the work I did, and I’m proud of what I accomplished, but the truth is, I wasn’t fair to myself, to my family, or even to my other clients.

I got so caught up in the passion, in the love of the work, that I lost sight of the bigger picture — the business side of things, the sustainability.

This realization has forced me to reevaluate how I approach my work and my relationships with clients. I’ve had to accept that being passionate about the work is great, but it can’t come at the cost of financial stability — for me or for my family. I need to get better at setting boundaries, at valuing my time properly, at diversifying my energy across all my clients instead of getting tunnel vision on just one.

So, as I move into 2025, I’m making some changes. I’m readjusting my engagements. I’m putting systems in place to keep myself accountable, to make sure I’m billing accurately, to make sure I’m spreading my time where it needs to be spread. I’m still not motivated by money, and I probably never will be — but I’m learning that it’s okay to prioritize it sometimes. It’s okay to say, "This is what my time is worth, and I need to honor that."

I know I’m not alone in this struggle. There are so many of us who love what we do, who are driven by the work itself rather than the paycheck. And that’s a beautiful thing. But it can also be dangerous if we let it go unchecked. Passion is powerful, but so is financial health. And in 2025, I’m aiming to find the balance between the two — so that I can keep doing what I love without sacrificing the stability that my family and I deserve.

Bring Your Own AI (BYOAI) - Empowering Users in the Age of Artificial Intelligence

AI has become an integral part of the services we use daily. From personalized recommendations to intelligent automation, AI enhances user experiences across platforms. However, as companies increasingly integrate AI into their products, a pressing concern arises: the lack of transparency and control over these AI systems.

Most AI solutions provided by companies operate as black boxes. Users have little insight into how these models function, how they handle data, or what decisions they make on their behalf. This opacity raises significant issues around privacy, trust, and user autonomy.

Enter Bring Your Own AI (BYOAI)—an approach that empowers users to connect their trusted AI services to the platforms they use. Instead of relying on proprietary AI models with unknown practices, users can choose AI providers they trust, ensuring greater transparency and control over their data.

What is BYOAI?

BYOAI is a framework that allows users to integrate their preferred AI services into various platforms. Imagine logging into a SaaS application or a website and having the option to:

• Connect with OpenAI
• Connect with Groq
• Connect with Ollama

By selecting one of these options, you're linking your personal AI account to the platform. From that point forward, any AI functionalities within the platform utilize your chosen AI service.

Why is BYOAI Important?

1. Enhanced Transparency and TrustUsers gain confidence knowing they control the AI interacting with their data. This transparency fosters a stronger trust relationship between users and platforms.
2. Personalized User ExperienceBy choosing their AI service, users can select models that best understand their preferences and needs, leading to a more tailored experience.
3. Data Privacy and ControlBYOAI ensures that users' data is processed by AI services they trust, addressing concerns about data misuse or unauthorized access.
4. Regulatory ComplianceAs data protection regulations like GDPR and CCPA emphasize user consent and control, BYOAI helps platforms align with these requirements by giving users autonomy over their data.

The Future of Human-AI Relationships

The BYOAI model represents a significant shift towards a more ethical and user-centric AI ecosystem. It acknowledges that while AI can greatly enhance our digital experiences, users should have a say in how it's implemented in their lives.

In the future, as AI becomes even more pervasive, the balance between innovation and user rights will be crucial. BYOAI offers a pathway to maintain this balance, ensuring that advancements in AI technology do not come at the expense of user trust and autonomy.

Conclusion

The adoption of BYOAI has the potential to redefine how we interact with AI in our daily digital activities. By prioritizing user choice and transparency, we can build a more trustworthy and ethical AI landscape.

Proposal for Implementing "Bring Your Own AI" (BYOAI) Framework

1. Executive Summary

This proposal outlines a detailed plan to implement the "Bring Your Own AI" (BYOAI) framework, enabling users to connect their preferred AI services to SaaS platforms, websites, and applications. By leveraging existing frameworks like OAuth 2.0 for secure authentication and the OpenAI API specification for standardized AI interactions, we aim to create a seamless, user-centric AI integration model that enhances transparency, control, and trust.

2. Introduction

As AI becomes ubiquitous in digital platforms, users are increasingly concerned about data privacy, transparency, and control over AI interactions. Proprietary AI models often lack transparency, operating as black boxes that process user data without clear user consent or understanding.

The BYOAI framework addresses these concerns by allowing users to integrate AI services they trust into the platforms they use. This proposal provides a comprehensive plan for executing and rolling out this framework, leveraging existing standards and technologies to ensure feasibility and scalability.

3. Objectives

• Empower Users: Allow users to choose and connect their preferred AI services.
• Enhance Transparency: Provide clear information about how AI services process user data.
• Ensure Security and Compliance: Utilize secure authentication methods and comply with data protection regulations.
• Leverage Existing Frameworks: Build upon established technologies like OAuth 2.0 and the OpenAI API spec.

4. Technical Overview

4.1 Architecture Design

The BYOAI framework consists of several key components:

• User Interface (UI): Where users select and connect their AI services.
• Integration Layer: Handles communication between the platform and various AI services.
• Authentication Module: Manages secure connections using OAuth 2.0.
• Data Processing Module: Ensures data is appropriately formatted and routed to the connected AI service.
• Compliance Layer: Monitors and enforces data protection and privacy regulations.

4.2 Leveraging Existing Frameworks

4.2.1 OAuth 2.0 for Authentication and Authorization

OAuth 2.0 is an industry-standard protocol for authorization, allowing third-party applications to access user data without exposing credentials. It provides:

• Secure Authentication: Users can securely connect their AI accounts.
• Access Control: Users grant specific permissions to the platform.
• Revocation Capability: Users can revoke access at any time.

4.2.2 OpenAI API Specification

The OpenAI API spec is becoming a de facto standard for AI service interactions. Utilizing this spec provides:

• Standardization: Consistent API endpoints and data formats.
• Compatibility: Easier integration with multiple AI providers following the spec.
• Extensibility: Ability to support additional functionalities as the spec evolves.

5. Implementation Details

5.1 API Integration Layer

• Abstracted API Calls: Create an abstraction layer that standardizes API calls to different AI services.
• Dynamic Endpoint Management: Use service discovery or configuration files to manage different AI endpoints.
• Error Handling: Implement robust error handling for API call failures, rate limits, and service unavailability.

Sample Code Snippet:

def send_request_to_ai_service(user, data):
    ai_service = user.connected_ai_service
    if ai_service == 'OpenAI':
        response = openai_api.call(data)
    elif ai_service == 'Groq':
        response = groq_api.call(data)
    else:
        response = default_ai_service.call(data)
    return response

(Refer to Appendix B for full code examples.)

5.2 User Interface and Experience

• Connection Workflow:
  • Step 1: User navigates to the AI integration settings.
  • Step 2: User selects "Connect with [AI Service]".
  • Step 3: User is redirected to the AI service's OAuth consent page.
  • Step 4: Upon successful authentication, the user is redirected back to the platform.
• Management Dashboard:
  • Display connected AI services.
  • Provide options to disconnect or switch services.
  • Show data usage and permissions.

UI Considerations:

• Clarity: Use clear language to explain what connecting an AI service entails.
• Simplicity: Make the connection process straightforward.
• Support: Provide help resources for troubleshooting.

5.3 Security and Compliance

• Data Encryption:
  • Use HTTPS for all data transmission.
  • Encrypt sensitive data at rest using AES-256 or equivalent.
• Access Tokens:
  • Store OAuth tokens securely.
  • Implement token refresh mechanisms.
• Privacy Compliance:
  • Update privacy policies to reflect data handling practices.
  • Ensure user consent aligns with GDPR, CCPA, and other regulations.

By adopting the BYOAI framework, we not only enhance user experience but also position ourselves at the forefront of ethical AI integration. This proposal serves as a roadmap to achieve a more transparent, user-controlled AI ecosystem.