GitHub Copilot

The Death of Artisanal Software and the Rise of the AI Native Founder We are witnessing a fundamental shift in how companies are built, transitioning from a world where humans wrote 80% of code to one where 80% is generated by models. This isn't just a technical evolution; it's an existential change for the startup ecosystem. As a former operator at Microsoft and Stripe, I’ve seen the transition from hand-crafted "artisanal" software to what is now becoming "mass-produced" software. For the first time since the 1960s, the capabilities we once only dreamed of in computer science are becoming reality through Large Language Models. The barrier to entry for prototyping has vanished. We are now in the era of "vibe coding," where a founder with a clear vision can iterate faster than a traditional engineering team ever could. This creates a new expectation in the venture capital world. If you show up to a pitch for a pre-seed or seed round without a working prototype, you are sending a signal that you haven't embraced the current paradigm. AI native founders are prioritizing building over deck-perfecting, and those who spend their nights vibe coding are the ones winning the market. The New Economics of Capital Efficiency and Distribution In the previous generation of startups, a seed round was essentially a hiring mandate. You raised a few million dollars to hire five engineers and sat in a basement for nine months to ship a product. Today, the AI native playbook is radically different. We are seeing founders hire a single engineer and then spend their remaining budget on "fleets of agents," tokens, and sophisticated workflows. The cost of building has collapsed, leading to a massive reallocation of capital toward distribution, brand, and marketing. This capital efficiency is creating a competitive environment where speed is the primary weapon. One of the most striking pitches I've seen recently featured a founding team comprised of an engineering manager and five "Devins" from Cognition AI. For roughly $2,500 a month, they were doing the work that would have previously cost hundreds of thousands in payroll. This shift forces us to rethink what a "company" actually looks like. If the cost of the "act of building" goes to near zero, then value must be found elsewhere. Defensibility in a World of Carbon-Copy Software If an agent can look at a competitor’s website and replicate a feature in an afternoon, where does defensibility come from? The answer lies in the "good old moats" of the 2010s: distribution, data, taste, and brand. To survive, founders must become subject matter experts who own the holistic workflow of a problem. A customer buys Linear not because they can't find another issue tracker, but because the team at Linear has the best "taste" and expertise in how project management should actually work. Owning the workflow is also the only way to build a data moat. By facilitating the full journey of solving a problem, you collect the specific reinforcement learning data needed to train agents that are better than generic models. A generic AI won't know the nuances of a specific accounting operation or how a venture capitalist reviews a deal. If you don't own the workflow, you can't collect the data, and if you can't collect the data, you can't build a specialized agentic system. This is where the next generation of giants will be built. Agent Experience is the New Developer Experience We are moving beyond Customer Experience (CX) and Developer Experience (DX) into the era of Agent Experience (AX). As startups increasingly use tools like Lovable, Cursor, and Replit to build their products, the underlying infrastructure must adapt. These "vibe coding" tools are not just toys; they are the new primary users of APIs. Take Resend as an example. When a user asks Lovable to build an email flow, the agent recommends Resend. This creates a massive growth loop where the GDP of a business is directly correlated to the GDP of vibe coding. Infrastructure providers now need to treat agents as a first-class client type. This means optimizing APIs for agent consumption, much like we once optimized web experiences for mobile phones. My former team at Stripe is already doing this with specialized servers that agents can talk to directly. If you aren't optimizing for agents, you are invisible to the most productive builders in the market. Bridging the Atlantic Gap in Tech Ambition Having spent decades in both Copenhagen and New York, the cultural divide between European and American tech ecosystems remains stark. In Denmark, there is often a "tall poppy" syndrome where success is defined by a stable middle-management role. While this has improved, the US still holds a significant lead in celebrating risk and taking "big swings." Europe has traditionally used American primitives to build vertical SaaS, but the next decade offers an opportunity for Europe to build its own sovereign infrastructure and cloud primitives in a new geopolitical reality. However, for a European founder to truly scale, they must adopt a global mindset early. Expanding from Denmark to Germany isn't a big swing; the real market is the US. New York City has emerged as the ideal landing spot for these founders. It is the second-largest tech ecosystem in the world and offers a time zone that allows for seamless collaboration with engineering teams back in Lisbon, Stockholm, or Copenhagen. If you want to build a foundational company, you need to be where your customers are, and for enterprise tech and AI, that is increasingly New York. Inside the AlleyCorp Incubation Machine At AlleyCorp, we don't just wait for the right founder to walk through the door; we build the companies we want to see. Our incubation process is born from operational conviction. If we see a tangible problem in healthcare, robotics, or AI that nobody is solving correctly, we put a team together and lead as the interim CEO. This allows us to lean into our experience as former operators to de-risk the earliest stages of company building. A prime example is Radical AI. We saw a massive opportunity at the intersection of material science and AI, incubated the team, and a year later they raised $60 million to build foundational models for new materials. This model works because we have an in-house engineering team that acts as an execution capacity for our portfolio. We aren't just writing checks; we are building the machine that builds the companies. In an agentic world, this ability to rapidly prototype and validate ideas is the ultimate competitive advantage.

The Premise of the Great Collapse Recent industry whispers and social media trends suggest that Software as a Service (SaaS) is facing an existential crisis. The argument, often echoed by leaders like Satya Nadella, posits that most business applications are merely CRUD databases wrapped in business logic. With the rise of AI agents and "vibe coding," many believe these platforms will collapse into a single, fluid agent era where bespoke internal tools replace expensive subscriptions. While the technical barrier to entry for building software is plummeting, the reality of running a global service remains stubbornly complex. The Barrier of Invisible Infrastructure Software development is often the simplest part of a successful SaaS product. High-utility platforms like Stripe or Squarespace do not just offer code; they provide a gateway to massive, regulated ecosystems. Consider Stripe. A developer might "vibe code" a functional payment button in an afternoon, but they cannot code the legal agreements with global banks, compliance with international tax laws, or the trust required to handle millions in transactions. The value lies in the hard-won partnerships and infrastructure that an AI agent cannot simply prompt into existence. Regulation and the Compliance Moat Regulatory requirements act as a natural defense for established platforms. An accounting SaaS must adhere to GDPR, ISO security standards, and local tax laws that vary by country. In the Netherlands, for instance, independent accountants often only support specific, validated platforms. You cannot replace a legally compliant audit trail with a custom-coded agent if the bank refuses to grant that agent API access or if the government doesn't recognize the output. These administrative and legal hurdles form a "moat" that protects the SaaS model from being completely disrupted by decentralized AI tools. The Future of Integrated Intelligence Instead of dying, SaaS is evolving to absorb the very tools meant to replace it. Platforms are already implementing Model Context Protocol (MCP) to allow AI agents to interact with their data seamlessly. We are moving toward a hybrid world where graphical user interfaces and chat interfaces coexist. The goal remains efficiency. It is still cheaper and more reliable to pay for a specialized service like Spotify than to build a custom player, negotiate music label licenses, and manage cloud streaming personally. SaaS isn't dead; it's simply getting smarter.

Overview Managing source code effectively is the difference between a streamlined release and a chaotic debugging session. This guide explores the mechanical and strategic nuances of Git branching. By using a FastAPI web application as a concrete example, we demonstrate how to isolate new features, maintain a clean history, and choose between different integration strategies like merging and rebasing. Understanding these patterns allows you to collaborate without stepping on your teammates' toes. Prerequisites To follow this tutorial, you should have a baseline understanding of Python syntax and the basic concept of version control. You will need a terminal environment, Git installed, and a package manager like UV or pip. Familiarity with basic HTTP methods (GET) and unit testing with Pytest is also beneficial. Key Libraries & Tools * **FastAPI**: A modern, fast (high-performance) web framework for building APIs with Python. * **GitKraken**: A visual Git client that simplifies branch management and history visualization. * **UV**: An extremely fast Python package installer and resolver. * **Pytest**: A framework that makes it easy to write small, readable tests. Code Walkthrough Initializing the API We start by defining a simple root endpoint. This serves as our stable baseline on the `main` branch. ```python from fastapi import FastAPI app = FastAPI() @app.get("/") def read_root(): return {"Hello": "World"} ``` Isolating Features via Branches Instead of modifying `main` directly, create a feature branch. This keeps the production-ready code clean while you experiment. We add a new `goodbye` endpoint and a corresponding unit test to verify it works. ```python @app.get("/goodbye") def say_goodbye(name: str = "World"): return {"message": f"Goodbye {name}"} ``` Merging vs. Rebasing When it is time to bring changes back to `main`, you face a choice. A **Standard Merge** creates a new commit that ties the two histories together. This preserves the exact context of when a feature was developed but can lead to a "spaghetti" visual history. **Rebasing** offers a cleaner alternative. It takes your feature commits, sets them aside, moves your branch to the tip of the current `main`, and then reapplies your work on top. This results in a perfectly linear history. If `main` hasn't changed since you branched, Git performs a **Fast-Forward**, simply moving the branch pointer forward without creating a new commit at all. Syntax Notes * **Feature Flags**: When using Trunk-Based Development, use boolean constants to toggle code paths. This allows you to merge unfinished code safely. * **Naming Conventions**: In GitFlow, prefix branches with `feature/` or `hotfix/` to organize the repository automatically. Practical Examples Real-world teams often use **GitFlow** for structured releases where separate `develop` and `main` branches exist. Alternatively, fast-moving startups might prefer **Trunk-Based Development**, pushing directly to `main` while hiding incomplete features behind logic toggles to avoid long-lived branch conflicts. Tips & Gotchas * **Rewrite History with Caution**: Never rebase a branch that others are also working on. It changes commit hashes and will break their local environments. * **Small Commits**: Commit early and often. Smaller commits make resolving merge conflicts significantly easier. * **Test Before Integration**: Always run Pytest on your feature branch before merging to ensure you aren't introducing regressions.

The Race to the Bottom AI models like DeepSeek represent a massive shift in how we perceive the value of code. While billions flow into companies like OpenAI and Microsoft, the reality is a swift race to the bottom. AI is becoming a commodity—a free or cheap feature integrated into existing tools rather than a standalone product worth a premium. For software engineers, this means the act of writing code is no longer the primary value driver. Shifting Expectations in Development Companies will not simply fire their entire engineering staff because of automation. Instead, they will move the goalposts. Management will expect developers to build three times as fast using tools like GitHub Copilot. The expectation shifts from "can you write this function?" to "can you design a robust, scalable system?" Efficiency is now the baseline, not the competitive advantage. The Evolution of the Junior Role Junior engineers face the most immediate pressure, especially in startup environments where first-version prototypes are easily generated by AI. However, this creates an opportunity for a more exciting career path. Instead of spending years on menial syntax tasks, juniors can engage with high-level architecture and design decisions much earlier. The role is becoming less about being a "coder" and more about being a software designer who understands how to orchestrate complex systems. Deepening the Moat through Architecture The only way to remain relevant is to go deep. Specialized skills in software architecture and complex system design provide a moat that AI cannot easily cross. While Apple Intelligence and other models can produce snippets or even small apps, they lack the human judgment required for nuanced design decisions. To thrive, engineers must use AI as a stepping stone to reach higher levels of abstraction and complexity.

Overview Setting up a Python development environment in VSCode often feels like a constant battle against broken imports, mismatched interpreter versions, and testing suites that refuse to discover your code. This guide moves past temporary fixes to establish a robust, professional workflow. We will focus on creating a project structure that Pylance understands and Pytest can navigate, using modern tools like UV for dependency management. Prerequisites To follow along, you should have VSCode installed and a basic understanding of the Python language. Familiarity with the terminal or command prompt is necessary for running installation commands and project initialization. Key Libraries & Tools * **UV**: A fast Python package installer and resolver written in Rust, used as a modern alternative to Poetry. * **Ruff**: An extremely fast Python linter and code formatter. * **Pylance**: The default language server for Python in VSCode, providing IntelliSense and type checking. * **Pytest**: A framework that makes it easy to write simple and scalable test suites. * **Even Better TOML**: An extension for better syntax highlighting and navigation in configuration files. Project Structure and Initialization Instead of installing packages globally, we use UV to create an isolated environment. Start by initializing your project in the terminal: ```bash uv init --no-workspace ``` A professional structure separates the logic from the metadata. Move your code into a `src` directory and include a `__init__.py` file to signal that it is a package. Your directory should look like this: ```text my_project/ └── src/ └── my_app/ └── __init__.py └── main.py └── tests/ └── test_main.py └── pyproject.toml ``` To add Pytest as a development dependency, run: ```bash uv add --dev pytest ``` Solving the Import and Test Discovery Crisis The most common headache is Pytest failing to find your modules because it doesn't know about the `src` folder. You fix this by adding a `pythonpath` setting to your `pyproject.toml` file: ```toml [tool.pytest.ini_options] pythonpath = "src" ``` However, Pylance might still show "reportMissingImports" in the editor even if tests run. You must align the editor's analysis with your runtime path by creating a `.vscode/settings.json` file: ```json { "python.analysis.extraPaths": ["./src"], "python.testing.pytestArgs": ["tests"], "python.testing.unittestEnabled": false, "python.testing.pytestEnabled": true } ``` Professional VSCode Configuration Managing settings across a team requires moving beyond global user settings. Use **Folder Settings** within the `.vscode` directory to ensure every developer on the project uses the same interpreter and formatter. Recommended Extensions Share a consistent toolset by creating `.vscode/extensions.json`. When a team member opens the project, VSCode will prompt them to install the necessary tools: ```json { "recommendations": [ "ms-python.python", "charliermarsh.ruff", "tamasfe.even-better-toml" ] } ``` Syntax Notes and Conventions * **TOML Folding**: Use the Even Better TOML extension to collapse large configuration blocks in your `pyproject.toml`. * **Bundled Formatters**: If you use the Ruff extension, enable the `useBundled` setting to avoid needing a separate local installation of the binary. * **Analysis Paths**: Always use relative paths (like `./src`) in `extraPaths` to ensure settings work across different machines. Tips & Gotchas * **Priority of Settings**: Remember that **Folder Settings** override **Workspace Settings**, which in turn override **User Settings**. If your project isn't behaving, check the local `.vscode/settings.json` first. * **Syncing**: Use VSCode's built-in Settings Sync for personal preferences like themes and fonts, but keep project-specific logic (like the Python path) in the repository. * **Source Folder**: Never name your root code folder `source` or `src` without an `__init__.py` if you intend to import it as a package; Pylance needs that marker to recognize the package boundary correctly.

The Dominance of the Domain Model Software development often gets bogged down in the minutiae of syntax and implementation. We argue over where to place comments or whether a function should be a class method. These details feel vital, but Domain-Driven Design by Eric Evans suggests they are secondary. The real heart of software is the domain model—a conceptual representation of data and behavior that mirrors the real-world problem you are solving. If your model is wrong, the most beautiful Python code in the world won't save you. Cultivating a Shared Ubiquitous Language One of the most critical steps in building robust systems is bridging the gap between developers and stakeholders. You cannot write effective software for a domain you do not understand. This requires cultivating a shared language. Developers shouldn't just take a list of requirements from a business analyst; they must engage in a feedback loop. This interaction uncovers technical constraints and conceptual misunderstandings early. Whether you are building an HR system or an Electric Vehicle interface, the language used in the code must match the language used by the domain experts. Trash Can Oriented Programming I view code as a temporary, evolving expression of a persistent domain model. Because models change as we learn more, we must optimize for iteration. This means writing code that is easy to throw away. We use patterns like the Strategy pattern or focus on reducing coupling specifically so we can toss out an old implementation and replace it without the whole system collapsing. If you treat your code as precious, you become resistant to the changes required to improve the model. Embracing "trash can oriented" development allows you to fail fast and refine the logic that actually matters. The Role of AI in Evolving Models Modern tools like GitHub Copilot change the equation of how we spend our time. AI is exceptionally good at handling the repetitive task of expressing a model in code. This shifts the developer's primary value away from syntax and toward analytical thinking. Our job is to crunch knowledge, establish constraints, and ensure the conceptual model makes sense. AI helps us cycle through versions of our code faster, which in turn lets us iterate on the underlying domain model at a pace previously impossible.

The Modern Backend Toolkit Transitioning Visual Studio Code from a simple text editor into a full-scale backend IDE requires more than just syntax highlighting. For modern developers, the goal is to minimize context switching. Every time you leave your editor to check a database, test an API, or review a Git history, you break your cognitive flow. By integrating these tools directly into the workspace, you maintain a unified environment that handles everything from HTTP requests to automated linting. Prerequisites To follow this guide, you should have a basic understanding of Python and FastAPI. Familiarity with Docker for containerization and Git for version control is also recommended. Key Libraries & Tools * Postman: A platform for building and testing APIs. * GitLens: An extension that supercharges the built-in Git capabilities. * Ruff: An extremely fast Python linter and code formatter. * SQLite Extension: A tool to explore and query SQLite databases inside the editor. Streamlining API Testing and Database Inspection Instead of juggling external clients, the Postman extension allows you to manage collections and environment variables directly. You can execute requests against a local uvicorn server and view formatted JSON responses without leaving your code. ```python from fastapi import FastAPI app = FastAPI() @app.get("/") def read_root(): return {"items": [1, 2, 3]} ``` When working with local data, the SQLite Extension enables a sidebar explorer. You can open a `.db` file and run queries or view table contents as HTML with a single click. This is far more efficient than writing manual fetch scripts just to verify data persistence. Syntax Notes and Performance The move from Pylint to Ruff represents a massive leap in performance. Because Ruff is written in Rust, it performs 10 to 100 times faster than traditional Python-based tools. To get the most out of it, configure your `settings.json` to format on save: ```json { "editor.formatOnSave": true, "editor.defaultFormatter": "charliermarsh.ruff", "notebook.formatOnSave": true } ``` Tips & Gotchas Always ensure your linter is compatible with your Python version. Older tools like Pylint often lag behind new syntax features in Python 3.12. Ruff provides immediate compatibility and can even automatically remove unused imports, keeping your codebase lean without manual intervention.