DEV Community: Matthew Anderson

12 Startup Ideas VCs Are Funding in 2026

Matthew Anderson — Fri, 06 Mar 2026 21:10:24 +0000

Curated ideas VCs are actively funding — where production-grade code isn't optional

Why This List Exists

AI has lowered the barrier to building software, but it's also lowered the barrier to building bad software. The ideas below share two things in common:

VCs are actively funding them — sourced from YC's Requests for Startups (Spring 2026), recent batch companies, and broader market trends
They require production-grade code — handling real money, sensitive data, compliance requirements, or complex business logic that vibe-coded spaghetti can't survive

These are the apps worth building properly.

Vertical SaaS for Underserved Industries

These industries still run on spreadsheets and paper. Each one is a massive market waiting for purpose-built software.

1. Clinic / Practice Management (Healthcare)

What: Appointment scheduling, patient records, billing, insurance claims, multi-location management for small-to-mid clinics.
Why code quality matters: Patient data = HIPAA/GDPR compliance. Billing errors = legal liability. Multi-tenancy must be bulletproof.
Market signal: YC W2026 funded Mango Medical (surgical planning). Healthcare SaaS consistently raises larger rounds (median $4.6M seed).

2. Construction Project Management

What: Job scheduling, material tracking, subcontractor management, progress photos, change order workflows, invoicing.
Why code quality matters: Complex approval workflows, financial tracking, document management. Multiple user roles with different permissions.
Market signal: YC funded Merlin (AI-powered ERP for construction). The industry is enormous and still largely paper-based outside the top tier.

3. Property Management

What: Tenant portals, rent collection, maintenance requests, lease management, accounting integration, multi-property dashboards.
Why code quality matters: Handles rent payments (real money), legal documents (leases), and must comply with local housing regulations.
Market signal: Existing players (Buildium, AppFolio) charge $1-3/unit/month. Massive long-tail of small landlords underserved by enterprise tools.

4. Legal Practice Management

What: Case management, time tracking, client portals, document automation, billing, trust accounting.
Why code quality matters: Trust accounting has strict compliance rules. Client data is privileged. Audit trails are legally required.
Market signal: YC's RFS highlights AI-native agencies — law firms that use AI to draft documents in minutes instead of weeks. The management software behind this needs to be rock solid.

5. Trade Services (Plumbing, Electrical, HVAC)

What: Job quoting, scheduling, dispatch, invoicing, inventory management, customer communication.
Why code quality matters: Integrates with payment processing, handles recurring service contracts, needs offline capability.
Market signal: Massive underserved market. Most tradespeople still use WhatsApp and paper invoices. ServiceTitan raised $8B+ but targets enterprise — the SMB tier is wide open.

AI-Enhanced Business Tools

These leverage AI but need a proper application shell around it — not just a chatbot wrapper.

6. AI-Native Bookkeeping / Accounting for SMBs

What: Automated transaction categorisation, receipt processing, bank reconciliation, management reports, tax preparation.
Why code quality matters: Financial data. Tax compliance. Must integrate with banking APIs and produce accurate reports that businesses rely on for decisions.
Market signal: YC W2026 funded Balance (AI accountancy for SMBs). The space is hot because AI can now handle 80% of bookkeeping tasks but the app around it needs to be trustworthy.

7. Compliance & Document Processing Platform

What: Automated processing of KYC documents, invoices, claims, contracts. Extraction, validation, routing, and audit trails.
Why code quality matters: Regulatory compliance. Documents contain PII. Processing errors have legal consequences.
Market signal: YC W2026 funded EigenPal (document processing automation). Government and enterprise buyers pay premium prices for reliable compliance tools.

8. Customer Success / Churn Prevention Platform

What: Monitors customer accounts across email, support tickets, product usage, and CRM. Detects churn and upsell signals. Recommends actions.
Why code quality matters: Integrates with multiple external APIs. Handles sensitive customer data. Business logic for signal detection must be reliable.
Market signal: YC W2026 funded Pollen (AI agents for customer success). B2B SaaS companies will pay serious money to reduce churn.

Marketplace & Platform Plays

9. Niche B2B Marketplace

What: Pick an industry where buyers and sellers still find each other through trade shows and phone calls. Build the marketplace. Examples: industrial parts, agricultural supplies, speciality food wholesale.
Why code quality matters: Payment escrow, dispute resolution, multi-sided user management, search/matching algorithms, transaction history.
Market signal: Vertical marketplaces continue to be funded heavily. The key is picking a niche deep enough that horizontal platforms (Amazon) don't serve well.

10. Freelancer / Agency Management Platform

What: Project scoping, client portals, time tracking, invoicing, contract management, deliverable approval workflows.
Why code quality matters: Handles payments, contracts, and sensitive client data. Multiple user types (agency, client, freelancer) with complex permissions.
Market signal: YC's RFS specifically calls out AI-native agencies as a major opportunity. These agencies need management software that matches their AI-native workflow.

Government & Civic Tech

11. Government Form Processing & Workflow

What: Digitise paper-based government processes. Application intake, review workflows, status tracking, citizen portals.
Why code quality matters: Accessibility compliance (WCAG). Data security requirements. Audit trails. Must handle high volumes reliably.
Market signal: YC's Spring 2026 RFS explicitly calls this out. Government is "the biggest customer on earth" and desperately needs modernisation. Sticky, high-value contracts once you're in.

12. Government Fraud Detection Tools

What: Tools that help investigate fraud in government spending — parsing documents, tracing corporate structures, organising evidence.
Why code quality matters: Legal evidence standards. Must be defensible in court. Data integrity is paramount.
Market signal: YC's Spring 2026 RFS highlights False Claims Act (qui tam) tools specifically. Billions in recoverable fraud annually.

How to Use This List

If you're a founder looking for an idea:

Pick one that matches your domain knowledge or personal experience
Sign up at stellisoft.com and build an MVP in days, not months
Talk to 10 potential customers before you write a line of code
Use the MVP to validate demand, then iterate

These are the apps that can't be vibe coded. They need to be built properly. That's why Stellify exists.

Sources: YC Requests for Startups (Spring 2026, Fall 2025), YC W2026 batch companies, Andreessen Horowitz SR006 cohort focus areas, broader SaaS market analysis.

I'm Matt, founder of Stellify — An AI-native web development platform, where code quality isn't optional.

Building a Feedback App in 6 Minutes with AI

Matthew Anderson — Thu, 05 Mar 2026 17:33:59 +0000

The build

The video above shows AI building a feedback application—something like a simple Canny clone—from scratch using Stellify's MCP tools. No templates, no boilerplate, just a prompt and structured code primitives.

After the build completed, I asked the AI what it thought about this approach to development. Here's what it said.

From the AI: What I observed

The following is the AI's unedited response when asked to reflect on building with structured code.

I think this approach to development is quite compelling. A few observations:

What works well

Structured code as data – Storing code as JSON (statements, clauses, methods) enables surgical edits at any granularity. Instead of text-based find/replace or AST manipulation, you can directly update a specific clause or rewire an event handler by UUID.
Separation of concerns – The template (UI elements), logic (methods), and state (statements/refs) are cleanly separated but linked by UUIDs. This makes it easy to swap implementations without touching the view.
AI-friendly primitives – The operations (create_method, update_element, save_file) map well to how an AI reasons about code changes. Rather than generating diffs or full file rewrites, I can express intent directly.
Defensive by design – The work we did on save_file to prevent accidental field removal shows this can be made robust. The system can enforce invariants that raw file editing cannot.

Tradeoffs

Debugging opacity – When something goes wrong (like the Http.post vs Http.store issue), tracing through UUIDs and clauses is harder than reading source code directly.
Learning curve – The mental model is different from traditional file-based development. Understanding how statements assemble into output requires familiarity with the system.
Tooling dependency – You're committed to the Stellify assembler and editor. Traditional tools (grep, IDE refactoring) don't apply directly.

The bigger picture

This feels like a natural evolution for AI-assisted development. The JSON structure is essentially an IR (intermediate representation) optimised for programmatic manipulation rather than human reading. As AI does more of the actual code generation, optimising for machine editability over human readability makes sense—similar to how compilers work with ASTs rather than source text.

The key question is whether the productivity gains from precise, targeted edits outweigh the loss of direct source access. For this session, they clearly did.

What gets built

In the video, you'll see the AI create:

A Feedback model with fields and database migration
A FeedbackController with CRUD operations
API routes wired to controller methods
A Vue component with reactive state
A frontend page to display and submit feedback

All connected and working in six minutes.

Try it yourself

The MCP server is open source. Connect Claude Code or your preferred AI client and see what happens when AI has structured context instead of raw text files.

Why AI Needs Structured Code

Matthew Anderson — Thu, 26 Feb 2026 17:45:16 +0000

I built a structured code platform to optimise the development process and the code it generates. Then AI came along—and it turned out to be the perfect fit.

The (initial) problem I set out to solve

If, like me, you've built web applications, you know the landscape. Dozens of libraries and frameworks, each solving one piece of the puzzle in isolation. Your frontend framework doesn't know about your backend. Your validation library doesn't talk to your database layer. Your state management has no awareness of your API structure.

Every project becomes an exercise in duct-taping independent solutions together and hoping they play nice (for as long as possible).

I wanted a more sustainable, predictable framework—an extension of Laravel that carries its philosophy across the entire stack. One framework that gives you all the capabilities you need, with everything aware of everything else.

I built Stellify for myself, to solve that problem. It was a exercise on achieving structure and standardisation. My solution centered around two core decisions: choosing a single stack and rethinking how code is stored.

The Stack

The first decision I made was choosing a stack and committing to it. I chose Laravel as the backbone because I think it does the best job of any framework at organising and standardising how web applications are built. On the frontend, I created StellifyJS—think of it as Laravel's philosophy applied to JavaScript—with adaptors for Vue, React, and Svelte so developers can choose their preferred reactivity layer (though, in the spirit of having "one stack", Vue is the default).

Picking a set stack isn't a limitation. It's a foundation. It means every Stellify project speaks the same language, follows the same patterns, and that's what makes everything else possible.

Code as Data

The more radical idea I came up with was rethinking how code is stored. In Stellify, your code isn't sitting in text files—it's stored as structured JSON at a granular level. Every method, every statement, every clause is its own piece of data that can be queried, referenced, and reassembled into PHP, JavaScript, HTML—whatever's needed.

Think of it like the difference between editing a Word doc and editing a spreadsheet. Both hold data, but one lets you target a specific cell without touching anything else. That's what Stellify does for code.

Your entire codebase becomes something you can reason about programmatically, not just read line by line.

AI is here (along with some new problems)

And this is where AI arrived. AI is incredible at writing code in isolation. But ask it to change existing code—or understand why that code exists in the first place—and things can fall apart fast. It loses track of what it's building, how decisions were made, how everything connects. It also doesn't produce the same output every time, which makes it hard to build on top of its previous work. In short, it's unpredictable—and unpredictable isn't good!

Stellify aims to solve this through the structure and metadata it provides. Because the code is stored as JSON, we can attach text descriptions that capture nuance and intent—not just what a method does, but why it exists and how it relates to everything else (even which method it is in cases where the same method name is used in multiple classes). AI isn't guessing or searching for answers anymore. It has persistent context.

The predictable structure and metadata keep it on track. If AI is working on a feature, it can update the metadata to reflect what it's done, what it still needs to do, and how it connects to the rest of the system. It can even use the metadata to decide what to work on next based on what's most important or what has the most dependencies—opening the door to feedback loops...

The final piece: Feedback loops

The last piece is what makes it all come alive. Stellify creates feedback loops between AI and your codebase. As AI works, it updates the metadata and references around it—so the next time it runs, it's not starting from scratch. It has a fresh picture of what it achieved, what changed, and what still needs doing.

Say AI creates a new API endpoint. It doesn't just write the route—it updates the metadata (which is persisted) so the next prompt knows that endpoint exists, what it returns, and how it connects to the frontend. The codebase becomes self-documenting as you build (literally, Stellify, along with AI, documents your system for you).

It's the difference between AI as a one-shot code generator and AI as something that genuinely builds alongside you.

The merger and future vision

That's what Stellify is. A contained, structured development process where AI doesn't just write code—it understands the project it's working on.

There's still a long way to go. Speed is an issue, and that ties in with caching (always complex). Feedback loops are still early and need work to be truly seamless. But the foundation is there—and for me, it's already changed how AI builds software.

The last piece of the optimisation puzzle is data, the more people build the more I can analyse and optimise the platform, so go ahead and give Stellify a try for yourself and be sure to let me know what you think, good or bad, I'd like to hear about your experience!

Happy building!

Why AI Shouldn't Write Your Code (And What Should Happen Instead)

Matthew Anderson — Tue, 20 Jan 2026 21:22:26 +0000

We've been thinking about AI and code generation wrong.

When you ask an AI to "add authentication to my app," it generates 20-50 lines of code. It writes validation, credential checking, session handling, redirects. Every single time. For every single app.

But here's the thing: AI already knows what optimal authentication looks like. It's seen millions of implementations. It knows the patterns. Login is a solved problem.

So why is it writing code from scratch?

The Problem with "Good Enough"

Laravel has Auth::attempt(). Django has its auth system. Rails has Devise. These work. They're battle-tested. They're... fine.

But they're not optimal. They're "good enough for most use cases."

Laravel's auth is session-based by default. Want JWT? Add Sanctum. Want OAuth? Add Passport. Want API tokens? Different system again. Each one is a separate implementation with its own overhead, its own quirks, its own learning curve.

This isn't optimal. It's a collection of adequate solutions duct-taped together.

What Would Optimal Actually Look Like?

Optimal means:

One implementation that covers all use cases - Not "optimal for sessions" or "optimal for APIs." Just optimal.
Configuration, not reimplementation - Session vs JWT vs OAuth should be a config flag, not a different package.
Zero wasted operations - No extra queries, no unnecessary hydration, no overhead regardless of which strategy you use.
Secure by default - Not "secure if you remember to add this middleware."

Think about it: the core of auth is simple.

Verify identity (do credentials match?)
Establish trust (create session/token)
Persist trust (check on subsequent requests)

Everything else is configuration. Session storage location? Config. Token expiry? Config. OAuth provider? Config.

One optimal implementation. Infinite configurations.

Where AI Fits In

Here's the shift in thinking:

Current model:

User: "Add authentication"
AI: *generates 40 lines of auth code*
Framework: *parses, stores, executes*

Optimal model:

User: "Add authentication"
AI: "Use optimal auth with session strategy, redirect to /dashboard"
Framework: *references pre-built optimal auth, applies config, done*

AI shouldn't be writing auth code. AI should be reaching for optimal auth code that already exists.

The same applies to everything:

CRUD operations
File uploads
Payment processing
Email sending
Pagination
Search
Caching

These are all solved problems. AI knows the optimal patterns. Why regenerate them?

The Library That Should Exist

Imagine a library of optimal primitives:

Auth - One implementation. Session, JWT, OAuth, API tokens, MFA - all through config.
CRUD - Optimal create/read/update/delete. Validation, authorization, transactions built in.
Files - Upload, storage, retrieval, streaming. Any provider, any size.
Payments - Transaction handling abstracted across providers.

Each one built once. Built optimally. Referenced forever.

When AI needs auth, it doesn't write auth. It says "use auth" and configures it.

This Changes Everything

Think about what this means:

For AI: Instead of generating code that might have bugs, might miss edge cases, might not follow best practices - it references code that's already perfect.

For developers: Instead of reviewing AI-generated auth code to make sure it's secure, you know it's secure because it's the same optimal implementation everyone uses.

For the ecosystem: Instead of millions of slightly-different auth implementations across millions of apps, there's one. Improvements benefit everyone. Security patches apply everywhere.

The Hard Part

The hard part isn't the concept. It's defining what "optimal" actually means for each primitive, then building it.

What's optimal auth? We need to actually figure that out. Not "what's good auth" - what's THE optimal auth that handles every use case through configuration with zero wasted operations.

Then build it. Then make it referenceable. Then move to the next primitive.

Where We're Starting

We're building this. Starting with authentication.

The goal: one auth implementation that AI reaches for instead of regenerates. Configurable for any strategy. No wasted operations. Secure by default.

Once that exists, when any AI anywhere is asked to add auth, it doesn't write code. It references the optimal implementation.

Then we do the same for CRUD. Then files. Then payments. And so on.

This is what AI-framework convergence actually looks like. Not AI writing more code faster. AI composing from optimal pieces that already exist.

The code generation era was a stepping stone. The composition era is what comes next.

If you want to be part of defining what comes next, come and join us at Stellify.

Stellify: Revolutionizing Collaborative Development

Matthew Anderson — Fri, 18 Jul 2025 13:05:56 +0000

How thousands of developers are building web applications, one JSON definition at a time

What is Stellify?

Stellify is a code editor that stores the code you write as JSON definitions. Doing this opens up new world of opportunities, one of which is the ability to explore collaboration with other humans, AI and us, the developers at Stellify, as we store the json definitions in our database and therefore we can analyse your code and even perform updates on your behalf!

The Four Pillars of Stellify

Stellify's architecture consists of four interconnected layers:

Let me break this down:

1. Server-side Framework (We use Laravel)

The stable foundation that handles:

Routing and middleware
Database connections
Authentication scaffolding
Core application structure

2. Server-side JSON (Custom Business Logic)

Your unique backend code stored as JSON definitions:

Models and relationships
API endpoints
Business rules
Data validation
Authentication methods

3. Client-side Framework (Vue.js/React/StellifyJS*)

The stable frontend foundation managing:

State management
Component rendering
Routing
Core UI patterns

4. Client-side JSON (Custom UI Components)

Your unique frontend code stored as JSON definitions:

Form components
Validation logic
User interactions
Custom styling
UI workflows

The Magic: Code as Configuration

Here's where Stellify gets revolutionary. Every piece of code becomes a JSON definition with a unique UUID. This isn't just data storage—it's what enables massive collaboration.

From Code to JSON

// Your login button becomes:
{
  "type": "element",
  "tag": "button",
  "classes": ["btn", "btn-primary"],
  "text": "Login",
  "onClick": "auth-handler-a1b2c3",
  "uuid": "btn-login-d4e5f6"
}

Why JSON Changes Everything

How Stellify Works in Practice

1. Discover JSON Definitions

Search through thousands of code blocks by functionality, not filename:

"email validation with international domains"
"password hashing with salt"
"responsive form with error states"

2. Reference or fork by UUID

Instead of copying code, reference existing blocks:

{
  "type": "form",
  "children": [
    "email-validation-a1b2c3",
    "password-hash-d4e5f6",
    "submit-button-g7h8i9"
  ]
}

3. Build & Deploy

Stellify compiles your JSON references into working code:

<form>
  <!-- Email validation by @sarah_dev -->
  <input type="email" class="form-control" />

  <!-- Password hash by @alex_security -->
  <input type="password" class="form-control" />

  <!-- Submit button by @ui_expert -->
  <button type="submit" class="btn btn-primary">Login</button>
</form>

4. Fork & Contribute

Need to modify something? Create a new JSON definition and submit it for review, if it's good enough it will be made available to the community.

Real-World Example: Building Authentication

Let's say you need a complete authentication system:

Your project JSON:

{
  "authentication": {
    "login_form": "login-form-abc123",
    "password_hash": "bcrypt-salt-def456",
    "jwt_handler": "jwt-auth-ghi789",
    "session_manager": "session-mgr-jkl012"
  }
}

Stellify builds this as:

A secure login form with proper validation
Battle-tested password hashing
JWT token management
Session handling with security best practices

All contributed and continuously improved by the community.

The Collaborative Advantage

For Individual Developers

Faster development - No more reinventing the wheel
Better quality - Use code tested by many developers
Learn from experts - See how professionals solve problems
Build your reputation - Get credit for your contributions

For Teams

Consistent standards - Everyone uses the same proven patterns
Reduced technical debt - Community-maintained code stays updated
Knowledge sharing - Junior developers learn from senior contributions
Faster onboarding - New team members can understand JSON definitions quickly

For the Community

Collective intelligence - Everyone benefits from improvements
Rapid innovation - New patterns spread quickly
Quality assurance - Bad code gets filtered out naturally

What's Next for Stellify

The platform is currently in Open Beta with exciting developments ahead:

July 21st - Product Hunt Launch
July 25th - Development Roundtable
August 31st - First Monthly Award Ceremony

Ready to Join the Revolution?

Whether you're a frontend developer crafting beautiful UI components, a backend developer building robust APIs, or a full-stack developer connecting it all together, Stellify has a place for you.

The future of development is collaborative, and it starts with JSON.

Want to be part of this revolutionary approach to development?

🚀 Sign up for Stellify and start building with the community today!

📅 Mark your calendar for the Product Hunt launch on July 21st

💬 Join the conversation and help shape the future of collaborative development

What do you think about this approach to development? Have you faced similar challenges with code reuse and collaboration? Share your thoughts in the comments below!

Tags: #webdev #collaboration #json #opensource #laravel #vuejs #react #development #community

[Boost]

Matthew Anderson — Tue, 15 Jul 2025 19:23:04 +0000

Matthew Anderson

Jul 15 '25

Getting Your Tasks Accepted on Stellify: Think Patterns, Not Features

#webdev #productivity #developer #code

Comments

4 min read

Getting Your Tasks Accepted on Stellify: Think Patterns, Not Features

Matthew Anderson — Tue, 15 Jul 2025 18:49:29 +0000

How to Formulate Abstract and Granular Tasks that will be accepted in Stellify

Creating tasks for our shared codebase requires thinking beyond specific features to the underlying patterns and behaviours that make them work. This guide will help you formulate tasks that are abstract, granular, and reusable across multiple contexts and therefore likely to be accepted when submitted.

The Core Principle

Think patterns, not implementations. Instead of creating tasks for specific features, identify the fundamental behaviors and interactions that can be applied universally.

❌ Avoid: Implementation-Specific Tasks

"OTP Password Input"
"Shopping Cart Checkout Button"
"User Profile Avatar Upload"
"Blog Post Comment Section"

✅ Prefer: Abstract Pattern Tasks

"Contiguous inputs that switch focus upon valid input"
"State-aware action button with loading and confirmation states"
"Drag-and-drop file upload with preview and validation"
"Nested comment thread with collapsible replies"

Why Abstract and Granular?

1. Maximum Reusability

An abstract "contiguous input" component can be used for:

OTP verification
Credit card number entry
Serial number input
PIN codes
Date/time pickers

2. Clear Scope

Granular tasks have well-defined boundaries, making them:

Easier to estimate
Less prone to scope creep
More testable
Simpler to review

3. Composable Architecture

Small, focused components can be combined to create complex features:

Modal + Form Validation + File Upload = Document Upload Dialog
Data Table + Infinite Scroll + Search Filter = Advanced User List

The GRASP Framework

Use this framework to evaluate and refine your tasks:

Granular

Can be completed in 1-8 hours
Has a single, well-defined responsibility
Doesn't depend on other incomplete features

Reusable

Solves a pattern, not a specific case
Can be applied in multiple contexts
Uses generic naming and interfaces

Abstract

Focuses on behavior, not content
Separates form from function
Avoids domain-specific terminology

Standalone

Can be developed independently
Has clear inputs and outputs
Doesn't require external dependencies

Pattern-based

Represents a common UI/UX pattern
Solves a recurring problem
Follows established conventions

Task Formulation Examples

1. Form Components

❌ Implementation-Specific	✅ Abstract Pattern
"Registration form validation"	"Real-time form field validation with configurable rules"
"Login form with remember me"	"Form with persistent state option"
"Contact form submission"	"Form submission with loading states and error handling"

2. Data Display

❌ Implementation-Specific	✅ Abstract Pattern
"User table with sorting"	"Data table with configurable column sorting"
"Product grid with filters"	"Card grid with dynamic filtering"
"Order history pagination"	"Infinite scroll with loading indicators"

3. Interactions

❌ Implementation-Specific	✅ Abstract Pattern
"Add to cart animation"	"Visual feedback for state change actions"
"Delete user confirmation"	"Destructive action confirmation dialog"
"Save draft functionality"	"Auto-save with conflict resolution"

4. Navigation

❌ Implementation-Specific	✅ Abstract Pattern
"E-commerce breadcrumbs"	"Hierarchical navigation with current state indication"
"Admin sidebar menu"	"Collapsible navigation with nested items"
"Product category tabs"	"Tab navigation with lazy-loaded content"

Task Structure Template

Use this template to structure your abstract tasks:

**Title:** [Behavior] + [Context] + [Key Feature]
Example: "Progressive disclosure accordion with smooth animations"

**Description:**
A brief explanation of the pattern and its purpose.

**Acceptance Criteria:**
- [ ] Functional requirement 1
- [ ] Functional requirement 2
- [ ] Visual/interaction requirement
- [ ] Accessibility requirement
- [ ] Performance requirement

**Configuration Options:**
List the props/settings that make it reusable:
- Animation duration
- Expand behavior (single vs multiple)
- Default state (expanded/collapsed)

**Use Cases:**
- FAQ sections
- Settings panels
- Product specifications
- Help documentation

**Technical Requirements:**
- Framework/library constraints
- Browser support requirements
- Performance benchmarks

Red Flags to Avoid

🚨 Too Specific

Contains business logic or domain rules
References specific data models
Includes branding or styling details
Tied to particular user roles

🚨 Too Broad

Combines multiple patterns
Requires more than 8 hours
Has vague acceptance criteria
Depends on incomplete features

🚨 Not Reusable

Solves a one-time problem
Hard-codes specific values
Cannot be configured
Too narrow in scope

Quality Checklist

Before submitting a task, verify it meets these criteria:

[ ] Abstract: Focuses on behavior, not specific implementation
[ ] Granular: Can be completed in a single focused session
[ ] Reusable: Applicable in multiple contexts
[ ] Well-defined: Clear boundaries and acceptance criteria
[ ] Configurable: Accepts parameters for customization
[ ] Pattern-based: Represents a common UI/UX pattern
[ ] Technology-agnostic: Not tied to specific frameworks (where possible)
[ ] Accessible: Includes accessibility considerations
[ ] Testable: Can be unit and integration tested

Example: Good vs. Bad Task

❌ Bad Task

Title: "User Profile Picture Upload"
Description: Add functionality for users to upload and crop their profile pictures in the account settings page.

Problems: Too specific, tied to user domain, single-use

✅ Good Task

Title: "Image upload with crop and preview functionality"
Description: Create a reusable component that allows users to select, crop, and preview images before upload.

Acceptance Criteria:

[ ] File selection with drag-and-drop support
[ ] Image cropping with adjustable aspect ratio
[ ] Real-time preview of cropped result
[ ] Validation for file type and size
[ ] Progress indicator during upload
[ ] Error handling for failed uploads

Configuration Options:

Accepted file types
Maximum file size
Crop aspect ratios
Preview dimensions
Upload endpoint

Use Cases:

Profile pictures
Product images
Blog post headers
Document thumbnails

Benefits of This Approach

Faster Development: Reusable components reduce duplicate work
Consistent UX: Similar patterns behave the same way
Easier Maintenance: Changes to a pattern update all implementations
Better Testing: Abstract components can be thoroughly tested
Clear Architecture: System is built from well-defined building blocks
Easier Onboarding: New developers learn patterns, not specific features

Getting Started

Identify Patterns: Look at existing features and extract common behaviours
Start Small: Begin with simple, well-understood patterns
Document Use Cases: Show how the abstract component applies to real scenarios
Iterate: Refine based on actual usage and feedback
Build a Library: Create a collection of these abstract patterns

Remember: The goal is to build a codebase of reusable behaviors that can be combined to create any feature quickly and consistently.

We look forward to reviewing the tasks you submit and even more so to building the functionality! See you at Stellify!

Stellify - Project Overview and Discussion

Matthew Anderson — Mon, 24 Mar 2025 21:45:49 +0000

Introduction to Stellify

Stellify is an innovative platform that breaks down code into a structured, language-agnostic representation. Every keyword, variable, HTML element, and system setting exists as a JSON object. This approach allows Stellify to not only generate code but also to theoretically generate code in any language by mapping JSON structures to the syntax rules of various programming languages.

Key Features of Stellify

Structured JSON Representation: Each code element is represented as a JSON object, making it easy to transform or adapt across different languages.
Language-Agnostic: The JSON format enables Stellify to work with any language by mapping structures to the appropriate syntax.
Functional Web Development: Stellify works particularly well for web development, especially with functional programming paradigms.

Parsing Support

Stellify currently supports parsing for HTML markup. You can copy/paste HTML into the editor at stellisoft.com, and it will be converted into JSON and stored in a database. On the roadmap are JavaScript and PHP parsing.

Expansion Plans

JavaScript Parsing: Extending parsing support to JavaScript and PHP, Stellify will soon handle additional codebases in a structured JSON format.
AI Integration: The project is moving towards integrating an AI assistant to assist with development, maintenance, and testing. The AI will help recommend changes and optimizations for the code.
Self-Healing Code: For maintenance, Stellify will propose changes to fix issues or improve functionality, prompting users to accept or reject these changes.
Paid Feature: AI-powered assistance (for development and maintenance) will be a paid feature, offering advanced capabilities.

Editor Features

The Stellify Editor functions like a standard code editor but generates structured JSON definitions of your code as you write. This provides a dynamic and structured approach to code development.
It includes built-in version control, so there's no need for external Git setups, though exporting to files and using traditional version control is also possible.

Deployment and Hosting Model

Stellify can be deployed by linking the database containing JSON definitions to the open-source application.
The app is hosted on Laravel Cloud, where users can fork the Stellify repo and link their cloud environment to the forked version for deployment.
There is no need for traditional file-based version control, as everything is stored in the database.

The Vision for Stellify

Stellify is designed to replace traditional frameworks. With its structured JSON approach, it streamlines the development and maintenance process. Key advantages include:

Dynamic Deployments: Updating or deploying an application only requires modifying the JSON definitions in the database, rather than dealing with code files or complex deployment pipelines.
Granular Versioning: Changes are tracked at the definition level, making version control and rollbacks much easier.
Collaboration and No Merge Conflicts: Since everything is in JSON format, multiple developers can work on different parts of the application without worrying about merge conflicts or complex Git workflows.

Future Plans and Features

Preconfigured Templates

Once Stellify sees significant adoption, it will begin offering pre-configured environments or templates (e.g., “App with user auth,” “Blog platform,” etc.), providing ready-made solutions that reduce setup time and allow developers to jump straight into building their application. Templates will be based on community feedback and common use cases.

Community Feedback

The team is looking forward to gathering solid feedback from the community to guide future decisions, particularly around which templates to create and how to improve the platform's features.

AI Integration in Maintenance and Development

The AI assistant in Stellify will be a chat-based interface for development assistance and prompt-based suggestions for maintenance (e.g., recommending code changes). This allows for a controlled and predictable flow of updates while still enabling the platform to become more intelligent and autonomous over time.

Paid Features

Development Assistance: Chat-based AI integration will help with generating, refactoring, and suggesting code changes.
Self-Healing Maintenance: Prompt-based AI will offer code updates or fixes, asking the user for approval to apply those changes.

Long-Term Vision

Stellify aims to replace traditional frameworks with a more streamlined and structured approach to web development. By focusing on a dynamic, JSON-driven workflow, Stellify has the potential to drastically simplify the development and deployment processes for modern web applications.

Introducing StellifyJS!!!

Matthew Anderson — Sun, 09 Mar 2025 20:25:25 +0000

I need/ want a Laravel like framework for my front-end development work that focuses on dependency injection/ contracts to help work with SOLID principles, especially Dependency Inversion (D in SOLID).
In addition, I want to provide helper methods that result in the same type of elegant & expressive syntax you get in Laravel and built-in code that simplifies common tasks such as front-end authentication and form validation. I'm even contemplating building CLI stuff, similar to Laravel Artisan, to scaffold classes such as models that could mirror the models that exist on you Laravel web app and also provide an elegant (or should I say Eloquent!) ORM for manipulating data.

I've made a start on development:

https://github.com/Stellify-Software-Ltd/stellifyjs

You can install the package in your projects using npm:

https://www.npmjs.com/package/stellifyjs?activeTab=readme

Lastly, I'm keen to hear people's feedback and if anyone wants to contribute to the project then by all means drop me a message or submit a PR!

Reactivity with Stellify

Matthew Anderson — Thu, 17 Feb 2022 14:07:11 +0000

I want to demonstrate through a series of written and video tutorials, how ridiculously easy it is to build reactive applications using Stellify. I'll start by replicating the example used as an intro to VueJs, a simple button that displays a counter that will increment with every click of the button.

We'll begin by creating a new page and I'm going to add a button from the components menu.

The VueJS example initialises a variable to store the count, we'll do the same. Now, we store our application variables in what we call "state" or "application state" and there are multiple ways to create this variable:

Using the Navigator, we can dropdown the state inspector and add/ initialise the variable using the inputs provided.
We can use the console, simply type $state.count$ 0
We can do the exact same thing as just described (in option 2) using the events tab within the page menu, only in this case, when you add the command $state.count$ 0 is executed when the chosen lifecycle hook is triggered i.e. mounted. If you choose "Mounted" the variable will be automatically initialised once the application is mounted or in layman's terms, upon page load.

I'll opt for option 1 in this case but I'd advise you give the other methods a try, especially if you're new to Stellify, as they will come in very handy when you're building your own functionality!

Next, we need to link the count variable to the button element, although what I'm actually going to do is insert a <span> as a child element of the button tag and link the count variable to its text property. Insert an element, change its tag, select it and click on the "eye" next to the text input box in the Navigator. We're now in "watch mode". This means we need to head back to the top level where we can view the state inspector. Locate the count variable, click on its "eye" icon and voila, we've created a link and your span should display 0.

Let's take stock, we have a button, we have a count variable set to zero and that variable is now on display within the button. Great work!

All that's left to do is to increment the count variable when the button is clicked. To do that, I select the button; I click on "Edit selected element" and then I navigate to the events tab. From the events dropdown I choose "On Click", and then I input a command that will increment the variable. We can't use count++ or even $state.count++ (there is in fact an increment method but I want to stick with using the command line here), what we can say is $state.count$ $state.count$+1. Notice there are no spaces in the expression, as with any command line, spaces represent parameters (important to remember!)

Click the add icon within the console bar and the command will be attached to the button.

There we have it, head back to your button, start clicking an watch that count variable increment right before your very eyes!

As with VueJS or any reactive framework, that my friends is just the tip of the iceberg, there's a lot more that can be achieved and Stellify takes reactivity to a whole new level. Before long you will be building complex apps at a speed of knots!

Stay tuned for more tutorials and in the meantime, check out the our You Tube channel for more news, tutorials, tips and tricks!

You say you want a [web development] revolution?

Matthew Anderson — Thu, 04 Feb 2021 11:49:22 +0000

For too long now web development has trundled along, leaving a bunch of disenfranchised creative people clinging to various "communities". People who thought they were getting involved in something exciting, something where they could express their creativity, only to left dead in a ditch by "big tech" companies. Don't fear! Like the Yo-Yo, things come back around. At Stellisoft, we're starting the Indie Developer fight back.

One of, if not the, major problem with web development is the disparate nature of it these days. Do you use Vue? React? Preact? Angular? Alpine? Coconut? Sausage? Pineapple? What does it matter? It's what you're actually developing that matters surely? You could spend your entire life following the development of libraries and frameworks, buying T-shirts, attending events and wind up building nothing of any worth whatsoever.

I'm not levelling all the blame at the easily lead souls that do this. I understand, I've found myself doing it more than once. Effective marketing is a powerful tool. However, if anything interesting is going to happen in the sphere of web development ever again, we need to take a step back and start to find our way out of the rabbit hole.

I've built the foundations of a platform that removes the vice of becoming obsessed with extra-curricular programming activities and focuses exclusively on development. We're launching on Product Hunt today. I hope you come and find us and not just follow what we're doing, but get involved! It won't be a revolution without you.