New stories

The article discusses the author's experience with a 30-day experiment of 'sitting and doing nothing', exploring the benefits of mindfulness, productivity, and personal growth that can arise from embracing stillness and presence in daily life.

Hi HN,

I’m Afraz (https://x.com/MM_AFRAZ ), a solo builder working on Vect AI.

While building and marketing SaaS products, I kept running into the same issue: AI tools are great at ideas and suggestions, but execution still breaks down into manual steps, scattered tools, and half-finished workflows.

Vect AI is my attempt to approach this differently — as an execution-first marketing operating system.

Instead of focusing on “what should I do?”, the system is designed around:

turning decisions into workflows that actually run

detecting conversion killers on landing pages (trust gaps, confusion, weak CTAs)

helping founders move from positioning → execution → distribution without tool sprawl

One example inside the platform is a Landing Page Roaster / Conversion Killer Detector that audits copy from a buyer’s perspective and highlights what’s actively hurting conversions, not just what could be improved.

This is still early and evolving. I’m building it in public and would genuinely appreciate feedback from people who’ve marketed or launched products themselves.

Project: https://vect.pro

I’d love thoughts on:

where execution tends to break most after planning

whether an execution-first “marketing OS” resonates

what would make something like this actually useful day-to-day

Thanks for reading — happy to answer questions.

Since vibe coding came into existence, I have been experimenting with building products a lot. Some of my products were consumer facing and some.. well, internal clones of expensive software. However, since beginning, I knew one big thing - the vibe stack was expensive.

I initially tried a lot of tools - Bolt, v0, Replit, Lovable, etc. out of which Replit game me the best results (yes, I can be biased due to my selection of applications). But I often paid anywhere from $25-$200/mo. Other costs like API, models, etc. made monthly bills upward of $300/mo. Was it cost effective when compared to hiring a developer? Yes. Was it value for money? NO.

So, over the months, I optimised by complete stack to be either free (or minimal cost) for internal use or stay at a much lean cost for consumer-facing products.

Here's how the whole stack looks today -

IDE - Google's AntiGravity (100% free + higher access if you use student ID)<br> AI Documentation - SuperDocs (100% free & open source)<br> Database - Supabase (Nano plan free, enough for basic needs) Authentication - Stack Auth (Free upto 10K users) LLM (AI Model) - OpenRouter or Gemini via AI Studio for testing and a custom tuned model by Unsloth AI for production. (You can fine-tune models using Unsloth literal in a Google Colab Notebook) Version Maintenance/Distribution - Github/Gitlab (both totally free and open source) Faster Deployment - Vercel (Free Tier Enough for Hobbyists) Analytics - PostHog, Microsoft Clarity & Google Analytics (All 3 are free and independent for different tracking, I recommend using all of them) That's the list devs! I know I might have missed something. If yes, just ask me up or list them up in the comments. If you have any questions related to something specific, ask me up as well.

Inspired by tsoding's recent video, I wanted to explore the limits of 3D rendering within the constraints of the terminal.

Built with Odin with no external libraries

The article discusses the evolving role of developers in the tech industry, arguing that the traditional focus on coding is shifting towards a more design-centric approach. It highlights the growing importance of design skills and user experience as key factors for successful digital products.

This article explores a novel sorting algorithm called Fibonacci Sort, which uses the Fibonacci sequence to efficiently sort arrays. The algorithm's performance is analyzed and compared to other common sorting methods, highlighting its potential benefits and practical applications.

The article examines Nexperia, a Dutch semiconductor company, and how it became caught between the geopolitical tensions of the United States and China, as the two world powers compete for control over critical technologies and supply chains.

The article discusses recent developments in the field of combinatorics, including new research findings, upcoming conferences, and the latest trends in the field. It provides an overview of the current state of combinatorics and highlights the ongoing contributions of researchers in this area of mathematics.

The article describes the creation of a Discord bot called Conbini, which allows users to easily access anime-related information and services within the Discord platform. The bot provides features such as anime recommendations, character details, and access to streaming platforms.

An explosion occurred in a ski resort bar in Switzerland, resulting in several fatalities. The incident is currently under investigation by authorities.

The article explores how big tech companies often turn various initiatives and endeavors into 'knife fights,' where they aggressively compete with each other, resulting in a cutthroat environment that may not always serve the best interests of customers or the industry as a whole.

The article discusses the Netflix film 'Train Dreams,' which explores the life of a railroad worker in early 20th-century America. It delves into the film's portrayal of the changing landscape and the impact of technological advancements on rural communities during that era.

The article discusses the history of the mouse cursor in Windows, tracing its evolution from the original text-based cursor to the modern graphical pointer. It explores the technical and design considerations that shaped the mouse cursor's development over the years.

GridInspector is a web application that allows users to visualize and analyze the structure of a grid-based layout. It provides tools for inspecting grid lines, cells, and the overall grid configuration.

dbcli is a command-line interface (CLI) tool that allows users to interact with various database management systems (DBMS) such as MySQL, PostgreSQL, and SQLite. The tool provides a unified interface for managing databases, enabling users to execute SQL queries, manage database objects, and perform administrative tasks across multiple DBMS platforms.

Today we’re releasing *Exponential CMS 6.0.11*, the latest release in the *Exponential CMS 6.0.x series*, formerly known as *eZ Publish 6*.

Exponential CMS is a *GPL-licensed PHP CMS originally created in the late 1990s*, designed from the start for Object Oriented Enterprise-scale content modeling, structured content, and long-lived systems. The software lineage includes eZ Publish, with *Exponential CMS 6.0.x continuing the eZ Publish 6 codebase under active maintenance and development*. While many platforms from that era disappeared or rewrote themselves into something unrecognizable, Exponential continues to evolve while preserving its core architectural principles.

For many PHP Developers who felt eZ Publish was Impressive before with only limited PHP5 support which is where the product was reborn by others in the community defending the continued use of their favorite GPL PHP CMS Framework by updating what would become 7x Exponential 6.x, Exponential Platform Legacy 2.5.0.1, and Exponential Platform 3.2.9 which all support PHP 8.3 or greater.

#### What’s new in 6.0.11

* *Official PHP 8.5 compatibility*

  * Kernel: (Minor) Deprecated and removed language features addressed
  * Kernel: (Minor) Updated internals to align with modern PHP execution and typing expectations

  * Reduced runtime warnings under common PHP configurations
  * Incremental improvements without breaking existing installations

Exponential sites that have been online for a decade or more—originally deployed as eZ Publish 5 installations—can upgrade PHP without abandoning their content model, templates, or editorial workflows.

#### Why this still matters

Most CMS platforms today are optimized for short-lived projects. Exponential exists for the opposite use case: *systems that must last*.

* Structured content, not pages * Enterprise-grade versioning and permissions * Designed for large editorial teams and complex publishing workflows * GPL, self-hosted, and vendor-independent

Exponential is the power user CMS is actively maintained by *7x*, with monthly updates and a focus on keeping long-running PHP CMS deployments viable on modern infrastructure.

In the shortest way possible: Exponential is easy to use by non-technical people. Exponential is even more powerful when used by php developers and designers to customize the UIs to match your own needs (Setup/Design). Everything after is a stable dream made possible by advanced design patterns and full circle features that never disappoint only leave you wanting EVEN more through thousands of built-in and supported customizations.

#### Links

* Project site: [https://exponential.earth](https://exponential.earth) * Download software: [https://exponential.earth/download](https://exponential.earth/download) * Source code: [https://github.com/se7enxweb/exponential](https://github.com/se7enxweb/exponential) * Forums & Community: [https://share.exponential.earth](https://share.exponential.earth) * Extensions/Designs/Plugins: [https://projects.exponential.earth](https://projects.exponential.earth) * Documentation: [https://doc.exponential.earth](https://doc.exponential.earth)

Questions, technical discussion, and criticism welcome. This project has survived multiple PHP generations already—and PHP 8.5 is just the next one. We are preparing for PHP 8.6+ now.

*Seattle, WA — January 1, 2026*

— *Graham Heath Brookins* Maintainer, Exponential CMS 7x

The article discusses the importance of shipping models at inference speed, highlighting the need for efficient and fast machine learning models to power real-world applications. It explores techniques and considerations for optimizing model performance and deployment to improve the user experience.

The article discusses Governor Calvo's decision to standardize the spelling of Chamorro words in Guam's government documents, citing the need for greater efficiency and cultural accuracy. The move aims to establish a consistent approach to Chamorro orthography across government agencies.

I’m a solo developer working on a “complex systems measurement” project that has grown to over 30k lines of code and is now at V12. Every line so far has been written by one person (me), with the research notes and design docs in a separate repo: https://github.com/Garylauchina/Prometheus-Research.

I’ve been using Cursor heavily along the way. The models are genuinely good and the local code they generate is often excellent, but on a large, evolving codebase I kept running into the same problem: context limits caused subtle architectural drift. The AI would write clean functions that were globally wrong, quietly breaking earlier design decisions and long‑range invariants.

What finally helped was to stop treating “AI” as a single assistant and instead treat different models as different team members with clear roles and constraints.

My current setup looks like this:

Perplexity + ChatGPT → “product / research brains” I use them for requirements, trade‑offs, and high‑level architecture sketches. They live outside the IDE and exist to clarify what I’m building and why before any code is touched.

Cursor, window 1 (GPT‑5.2) → “architect” This instance is not allowed to write production code. It is responsible for architecture and module boundaries, writing design notes and developer guides, defining interfaces and contracts, and reviewing diffs. I treat it like a senior engineer whose main output is prose: mini‑RFCs, comments, and checklists.

Cursor, window 2 (Sonnet 4.5) → “programmer” This one only implements tasks described by the architect: specific files, functions, and refactors, following explicit written instructions and style rules. It doesn’t get to redesign the system; it just writes the code.

The key rule is: architect always goes first. Every non‑trivial change starts as text (design notes, constraints, examples), then the “programmer” instance turns that into code.

This simple separation fixed a lot of the weirdness I was seeing with a single, all‑purpose assistant. There is much less logical drift, because the global structure is repeatedly restated in natural language. The programmer only ever sees local tasks framed inside that structure, so it’s harder for it to invent a new accidental architecture. The codebase, despite being tens of thousands of lines, feels more coherent than earlier, smaller iterations.

It also changed how I think about Cursor. Many of my earlier “Cursor is dumb” moments turned out to be workflow problems: I was asking one agent, under tight context limits, to remember architecture, requirements, and low‑level implementation all at once. Once I split those responsibilities across different models and forced everything through written instructions, the same tools started to look a lot more capable.

This isn’t a Cursor ad, and it’s not an anti‑Cursor rant either. It’s just one way to make these tools work on a large solo project by treating them like a small team instead of a single magical pair‑programmer.

One downside of this setup: at my current pace, Cursor is happily charging me something like $100 a day. If anyone from Cursor is reading this – is there a “solo dev building absurdly large systems” discount tier I’m missing?

SquareFace is a mobile app that allows users to easily create and share photorealistic 3D avatars of themselves. The app uses advanced computer vision and machine learning algorithms to generate highly detailed digital representations of a user's face, which can then be used in a variety of digital applications.

Hi HN,

I’m not a professional developer, but I’ve been obsessed with the idea of "Human Entropy." With the rise of quantum computing, I started wondering: Can we create a random sequence that no machine can predict because its source is the unpredictable nature of human behavior?

I built this web app using Flutter and Firebase. It's a simple idea: users perform actions on the web client, and those unique interaction hashes are sent to a secure Firestore pool. A server-side Cloud Function (hidden from the client) then joins these hashes daily to create a massive, non-deterministic random string.

Key Security Measures:

App Check: To prevent bot-driven entropy.

One-way Write: Users can only append to the pool; they can't read or modify existing data.

Hidden Logic: The actual concatenation happens in the cloud, so the core logic isn't exposed in the frontend.

It’s still a work in progress and currently supported by a small community of 15 people. I’d love to get your feedback on the logic and, more importantly, have you contribute your own "entropy" to the pool.

URL: https://entropygrid.net

Looking forward to a brutal but honest technical discussion!

The article discusses how the process of setting up a new PC has become increasingly complex and frustrating, with the inclusion of various advertisements and pre-installed software that can be difficult to remove or customize.

The article explores the importance of critical thinking and how it shapes our understanding of complex issues. It emphasizes the need to question assumptions, consider multiple perspectives, and approach problems with an open and analytical mindset.