With ideas like lean and fail quickly being at the forefront of startups and SaaS development, it makes sense not to spend a significant amount of time uhm-ing and ah-ing about which technologies to choose for MVPs. Unfortunately, this is often a trap many new founders fall into. Common advice is to simply pick a stack you're most comfortable with and just start, and this is excellent advice. If you need to migrate later, so be it, but it is pointless to prematurely optimise your stack and learn technologies for a product that no one wants. With this in mind, I will introduce a highly efficient and cost-effective stack that can be tailored to your needs. Depending on the scope of your project, you can deploy different components of this stack. For instance, if you're aiming for just a landing page with a waiting list, you can choose to deploy only the frontend component.





### The Stack at a Glance

* NextJS - Initial Cost $00.00
* Netlify - Initial Cost $00.00
* Fast API - Initial Cost $00.00
* Cloud Run - Initial Cost $00.00
* Stripe Billing - Initial Cost $00.00
* Clerk.Dev - Initial Cost $00.00
* Firestore - Initial Cost $00.00
* Gandi.net - Initial Cost (Cost of Domain)

Let's look at each component in this stack.

### NextJS

NextJS is an open source modern react framework. It has sane routing and multiple rendering modes including build time rendering, making SEO for landing pages much easier. I personally recommend sticking to the pages router until the app router feels more friendly.

### Netlify

The free tier on Netlify is well-suited for micro SaaS validation due to a variety of features at no cost. It includes 100GB of bandwidth, 300 build minutes, and allows for 500 sites, aiding in testing multiple ideas. Moreover, it provides 125k serverless function invocations and 100 form submissions per month, facilitating backend operations and user engagement respectively, essential for a micro SaaS setup. There are also benefits such as deploy previews, and building simply by linking a nextjs github repository. 

#### Why Not Vercel?

Simply put, the vercel free tier prohibits commercial deployments. This can be seen in the [fair use policy](https://vercel.com/docs/limits/fair-use-guidelines#commercial-usage).

### FastAPI

FastAPI, a potent Python web framework, is lauded for its rapid deployment of APIs and superb performance, often outpacing traditional Python frameworks with its automatic API documentation and simplified validation through Pydantic.

#### Benefits & Considerations

Despite its praise, container cold starts may deter some, especially in serverless setups where latency is critical. (More on this later.)

#### Why a Backend Despite Netlify’s NextJS Server Route Support?

Though Netlify does support NextJS API routes, a separate backend, like one utilizing FastAPI, is often prudent for enhanced scalability, reinforced security, and managing complex business logic—ensuring your application is not just nimble but also robust and secure as it scales. Remember: choose, build, iterate, and scale using the technologies that align with your expertise and project needs. The journey is replete with adjustments and learning; let the tech be a stepping stone, not a stumbling block.

### Cloud Run

Cloud run is part of the google cloud platform and allows you to deploy containers (that listen for http requests) on demand. The free tier is incredibly generous, (though can become expensive at scale, at which point you should probably migrate away.) With 2,000,000 requests a month,  360,000 GB-seconds of memory, 180,000 vCPU-seconds of compute time, and 1 GB of Egress (from North America) per month.

The astute will have realised that there are more than 180,000 seconds in a month, however with cloud run your deployment can be configured to only be running when it recieves a request, this means you are not charged when you are not recieving requests. Of course the caveat to this is that there is an initial startup time when a container has stopped. So this might not be ideal for those who write slow backends. But once a container has started, it will remain idle for approximately 15 minutes before shutting down. (You are not charged for idle time)

### Stripe Billing

Let's navigate the financial component of our stack: Stripe Billing. Renowned for its seamless integration and transparent pricing, Stripe has etched itself as a fundamental tool for digital entrepreneurs, especially for those building MVPs in the SaaS space.

#### Ease of Setup

When threading the needle through MVP development, simplicity is key. Stripe Billing encapsulates this by offering an easy setup, gracefully integrating with even the most elementary stacks like NextJS, Netlify, and Clerk.Dev. With copious documentation and a developer-friendly API, you can configure it to accommodate your specific use-case without trudging through complex setup processes.

#### Pay as You Grow

Embarking on a lean startup journey often implies being mindful of costs, and Stripe resonates with this sentiment. The initial plan operates on a pay-as-you-go model. You're not burdened with ongoing monthly fees; instead, a fee is incurred per transaction, aligning your costs directly with your revenue and aiding in maintaining a lean financial operation.

#### Flexible & Robust Product Handling

In the dynamic ecosystem of SaaS, your billing solution must be versatile. Stripe Billing champions this by allowing management of multiple products and subscriptions with aplomb. Whether you’re offering free trials, managing numerous product tiers, or orchestrating varying billing cycles for subscriptions (e.g., premium vs. standard, or monthly vs. yearly vs. lifetime subscriptions), Stripe navigates these intricacies with ease. It empowers you to create a billing system that can morph alongside your evolving product offerings and business model, without demanding an overhaul as your MVP evolves into a mature product.

### Clerk.Dev

Diving into Clerk.Dev, it shines as a user authentication and management solution, saving valuable time compared to crafting this system from scratch. It's a breeze to integrate with our stack, particularly with NextJS and Netlify, at an inviting initial cost of $00.00. The pay-as-you-grow pricing model is a boon for bootstrapped startups, only scaling costs as your user base expands. Security is well-handled, with built-in measures to safeguard user data. The robust API and well-outlined documentation make it developer-friendly, simplifying the task of integrating a secure and effective user authentication system in your MVP journey. Clerk.Dev’s offerings are geared towards easing the early-stage hustle, letting you channel your efforts towards core product validation and development.

### Data Storage

#### Metadata Management with Clerk.Dev

In the realm of SaaS, especially those with minimal data requirements, metadata handling is vital, yet often overlooked. Clerk.Dev deftly handles metadata through three classifications: public, private, and unsafe. Public metadata is accessible by anyone, making it ideal for storing non-sensitive data. Private metadata is secured and only accessible by authorized entities, perfect for storing user-specific data. Unsafe metadata, although stored server-side, should never house sensitive information as it's not encrypted. This triad of metadata management equips you with the flexibility to handle data responsibly and in alignment with your application's data sensitivity levels.



#### Firestore: Broadening Data Horizons

Transitioning to scenarios necessitating more extensive data storage, Firestore emerges as a formidable choice. Part of Firebase's suite, Firestore's free tier is substantial, offering 1 GiB of storage and 10k writes, 50k reads, and 20k deletes per day. This generous allotment is conducive for validating your SaaS idea without incurring costs.

The NoSQL database is structured to scale effortlessly with your project, and its real-time syncing capability ensures data consistency across your application, a critical feature as your user base expands. Integration with our stack is straightforward, and coupling Firestore with Clerk.Dev for user authentication creates a robust foundation for managing both user and app data efficiently. Its granular security rules further ensure data integrity and accessibility are finely controlled.

The seamless transition from Clerk.Dev's metadata management to Firestore's broader data storage capability exemplifies a well-thought-out data management strategy, crucial for scaling your SaaS application while keeping operational overheads lean. This duo caters to varying data needs, ensuring your tech stack remains efficient and cost-effective from MVP to a mature product.



### Gandi.net

Finally, Gandi.net. It may seem strange that I have listed a domain registrar as a part of the tech stack, but when you buy a domain through gandi.net, you get 2 free mailboxes for a year. This is a seemingly small yet significant perk, especially in the embryonic stages of a micro SaaS business. These mailboxes are essentially all that's needed to validate a micro SaaS idea, and they integrate seamlessly with the Clerk.Dev email verification system.

Specifically, having a domain like <notifications@<yourdomain>> is paramount. It not only lends a professional veneer to your outgoing emails but also ensures that the email verification process is smooth and trustworthy from a user's perspective. Gandi.net’s offering dovetails nicely with Clerk.Dev's email verification mechanism, thereby streamlining the user onboarding process. This is a prime example of how different components of your tech stack should interlock to create a seamless and professional user experience, even in a micro SaaS setup.



### A Modular Stack

The beauty of the proposed tech stack lies in its modularity and the ability to pick and choose components based on the specific needs and stage of your SaaS project. Not every element is requisite to kickstart your journey; the stack is designed to be as lean or as robust as your project necessitates.

For instance, if your initial goal is to validate your idea with a landing page to gauge interest, a combination of NextJS and Netlify might suffice. This duo allows you to swiftly deploy a professional-looking landing page with minimal fuss, enabling you to collect leads and measure interest in your offering.

As your project evolves, and you find the need to introduce user authentication, Clerk.Dev easily integrates into your existing setup, adding a secure and efficient user management layer. Similarly, as your data needs grow, introducing Firestore into your stack provides a scalable and powerful database solution without a steep learning curve or complex migration processes.

Each component in this stack serves a distinct purpose, and the decision to utilize them should align with the current needs and long-term vision of your project. The stack's flexibility allows for seamless integration and disintegration of components, ensuring your tech setup remains agile, scalable, and cost-effective throughout your project's lifecycle.

This tailored approach empowers you to maintain a lean operation, prioritizing resources and efforts towards validating and iterating on your core product offering. It underscores the principle of not over-engineering solutions prematurely, but rather evolving your tech stack in tandem with your project’s growth and validation milestones.



### To Conclude

Embarking on a micro SaaS journey entails navigating through a plethora of decisions, each with the potential to accelerate or hinder your venture. The tech stack delineated herein is meticulously curated to foster a smooth sail from ideation to validation, offering a blend of modularity and robustness, sans the hefty price tag.

The essence lies in the stack's ability to morph in alignment with your project's stage and needs. Whether you are at the helm of a budding idea validated through a simple landing page via NextJS and Netlify, or steering a growing project necessitating robust user authentication with Clerk.Dev and expansive data handling with Firestore, this stack is engineered to adapt seamlessly.

Each component is a cog in a well-orchestrated machine, designed to reduce operational friction, expedite the validation voyage, and lay a solid foundation for scalable growth. The flexibility to pick and choose components ensures your tech setup remains lean yet potent, ready to evolve in tandem with your project's trajectory.

As you venture into the micro SaaS realm, armed with a tailored tech stack, may your focus remain undiverted towards solving real-world problems and delivering value to your users. The journey from a nascent idea to a validated product is exhilarating, and with the right tools in your armory, the path is significantly smoothened, propelling you forward with confidence and agility.

Avoiding the Stack Trap: An Almost Free Stack to Validate Your Micro SaaS

### Introduction

The software development world is notorious for its stereotypes—one such stereotype being the dismissive or unhelpful responses from developers on online forums. To poke fun at this phenomenon, I created a chatbot named "10x-Helper." What sets it apart? The majority of its code was generated by ChatGPT. The bot serves up typical unhelpful and sarcastic responses to users. This blog post will delve into how ChatGPT was used to generate most of the code, which technologies were incorporated, and how the application works. Here's the [demo](https://www.miserablemillennial.com/10x-helper) for you to check out!

### The Technology Stack

- React: For crafting the front-end and interactive chat window.

- TypeScript: Used to add type safety, improving the codebase's maintainability.

- ChatGPT: Not just an inspiration but the primary code generator for this project.

### The Source Code

If you're a code enthusiast, here's where you'll find the source code. Most of this code was generated by ChatGPT, proving how AI can significantly speed up the development process.

```TypeScript

type ChatMessage = {
  id: number;
  type: "user" | "bot";
  content: string;
};

const getRandomUnhelpfulResponse = (): string => {
  const unhelpfulResponses: string[] = [
    "Did you even try to Google it?",
    "This question shows a lack of effort.",
    "Read the documentation.",
    "This question is a duplicate.",
    "This is basic stuff, you should know this.",
    "If you don't understand this, you shouldn't be programming.",
    "Seems like a homework question. We won't do your homework for you.",
    "Why would you want to do that? That's not the right way.",
    "Clearly, you haven't done your research.",
    "Not a real problem.",
    "This is trivial to implement.",
    "That's not how you should approach this.",
    "You're thinking about it all wrong.",
    "That's a waste of time.",
    "Don't bother with that approach.",
    "Not worth discussing.",
    "You're missing the point.",
  ];

  const randomIndex = Math.floor(Math.random() * unhelpfulResponses.length);
  return unhelpfulResponses[randomIndex] + "\n" + "Discussion closed.";
};

const ChatWindow: React.FC = () => {
  const [message, setMessage] = useState<string>("");
  const [chatHistory, setChatHistory] = useState<ChatMessage[]>([
    { id: 0, type: "bot", content: "Hello, how can I assist you today?" },
  ]);
  const [enabled, setEnabled] = useState<boolean>(true);

  useEffect(() => {
    scrollToBottom();
  }, [chatHistory]);

  const chatRef = useRef<HTMLDivElement>(null);
  const scrollToBottom = () => {
    if (chatRef.current) {
      chatRef.current.scrollTop = chatRef.current.scrollHeight;
    }
  };

  const handleSendMessage = () => {
    if (!enabled) {
      return;
    }
    const userMessage: ChatMessage = {
      id: chatHistory.length,
      type: "user",
      content: message,
    };

    // Immediately add user's message to chat history
    setChatHistory((prev) => [...prev, userMessage]);

    // Prepare for bot's message
    const botResponse = getRandomUnhelpfulResponse();
    let charIndex = 0;

    // Initialize with '...' to signify the bot is typing
    setChatHistory((prev) => [
      ...prev,
      { id: prev.length + 1, type: "bot", content: "..." },
    ]);

    // Create a function that will be called to simulate typing
    const simulateBotTyping = () => {
      setChatHistory((prev) => {
        const newHistory = [...prev];
        if (charIndex < botResponse.length) {
          newHistory[newHistory.length - 1].content = botResponse.slice(
            0,
            charIndex + 1,
          );
          charIndex++;
        }
        return newHistory;
      });

      if (charIndex >= botResponse.length) {
        clearInterval(botTypingInterval);
      }
    };

    // Schedule the simulateBotTyping function to run every 100ms
    const botTypingInterval = setInterval(simulateBotTyping, 100);

    setMessage("");
    setEnabled(false);
  };

  return (
    <Box
      sx={{
        display: "flex",
        gap: "1em",
        flexDirection: "column",
        width: "100%",
        minHeight: "65vh",
        overflow: "hidden",
      }}
    >
      <Paper
        ref={chatRef}
        sx={{
          flexGrow: 1,
          flexDirection: "column",
          display: "flex",
          overflow: "scroll",
        }}
      >
        <List
          sx={{
            flexGrow: 1,
          }}
        >
          {chatHistory.map((msg, index) => (
            <ListItem key={index}>
              <ListItemText
                primary={
                  <Typography
                    sx={{
                      backgroundColor:
                        msg.type === "user" ? "#e0f7fa" : "#e0e0e0",
                      borderRadius: "12px",
                      padding: "8px",
                    }}
                    align={msg.type === "user" ? "right" : "left"}
                  >
                    {msg.content}
                  </Typography>
                }
              />
            </ListItem>
          ))}
        </List>
      </Paper>
      <Paper
        sx={{
          display: "flex",
          padding: "8px",
          gap: "1em",
          width: "100%",
          height: "100%",
        }}
      >
        <TextField
          fullWidth
          disabled={!enabled}
          variant="outlined"
          value={message}
          onChange={(e) => setMessage(e.target.value)}
          onKeyDown={(e) => {
            if (e.key == "Enter" && enabled) {
              handleSendMessage();
              e.preventDefault();
            }
          }}
        />
        <Button
          variant="contained"
          color="primary"
          onClick={handleSendMessage}
          disabled={!enabled}
        >
          Send
        </Button>
      </Paper>
    </Box>
  );
};

export default function Page() {
  return (
    <>
      <Container
        sx={{
          display: "flex",
          flexDirection: "column",
          alignItems: "center",
          justifyContent: "center",
          width: "80vw",
          minHeight: "70vh",
          maxHeight: "70vh",
        }}
      >
        <ChatWindow />
      </Container>
    </>
  );
}
```

### How It Works



#### ChatGPT's Role in Code Generation

The chatbot is unique because ChatGPT generated most of its code. From structuring the chat interface to implementing the feature where the bot appears to type in real-time, ChatGPT had a significant role in accelerating the development process. I merely made minor tweaks now and then



#### Chat Interface

I utilized a, GPT generated, React functional component called ChatWindow as the cornerstone for managing the state of both user and bot messages. The Material UI framework was used for designing the UI components like the chat window, the message input area, and the send button. The Snarky Responses

The bot's pre-defined sarcastic replies are stored in a string array named unhelpfulResponses. When it's time for the bot to answer, the function getRandomUnhelpfulResponse() selects one of these quips at random.

#### The Typing Simulation

To enhance the realism of the bot, a typing simulation was added. When a user submits a message, a "..." appears, signaling that the bot is typing. The message then unfolds one character at a time.


#### Disabling User Interaction

To further the realistic feel, the application disables user interaction while the bot is "typing." This ensures the user can't send more messages until the bot finishes its snarky reply.

### Challenges and Limitations

The main limitation is that the bot's responses are static and pre-defined. While ChatGPT was instrumental in code generation, the bot doesn't employ real-time text generation for its responses. But remember, this limitation is by design—the bot is meant to be satirically unhelpful.

### Conclusion

The 10x-Helper chatbot serves as both a humorous take on a common stereotype in the tech world and an example of how AI-generated code can accelerate development. By using React, TypeScript, and primarily ChatGPT for code generation, the application highlights how AI and traditional coding can come together to create something uniquely entertaining and thought-provoking.

Don't forget to experience the satire yourself with the 10x-Helper Demo.

When Stack Overflow Meets ChatGPT: The Ultimate Chatbot

As a software engineer, efficiency and speed are of the essence. In my journey to optimize my workflow, I've found ChatGPT-4 to be an invaluable tool. In this blog post, I'll share some of the ways I have incorporated ChatGPT into my day to day role, and the prompts I use with examples.

### Disclaimer

* Version: For the purposes of this post, I am using ChatGPT-4 and not its previous iterations.
* Licensing & Work Rules: Always consider licensing and work-related rules before posting or sharing any source code. Make sure you are allowed to use, modify, and share the material.

### Generating Pull Request Descriptions From Git Diffs

Writing PR descriptions is boring and repetitve... most of the time. PRs always feel self explanatory and it's very easy to get lazy. It's also very annoying to deal with your own lazyness months or years later. You're trying to understand the history and cursing yourself for not writing more.
Well it's now significantly easier to remove some of this work (in most cases by leveraging an LLM like ChatGPT.). 

#### How I Do This

I typically follow this workflow:

1. `git diff > diff.txt`
2. Copy the parts I want (You quickly learn GPT likes to waffle on about extremely trivial changes)
3. Write the prompt

#### An Example

> Generate me a PR description based on the following diff:
> <diff>

The diff was taken from this [pytest pull request](https://github.com/pytest-dev/pytest/pull/11416/files)

And ChatGPT produced this response:  

> Summary
>
> This PR includes substantial refactoring and type hinting improvements in the pytest's doctest and fixtures modules. The changes are primarily focused on simplifying code, improving type hinting, and removing duplicated or unnecessary logic.
> Files Changed
>
> ```
> src/_pytest/doctest.py: 24 additions & 38 deletions
> src/_pytest/fixtures.py: 36 additions & 34 deletions
> src/_pytest/python.py: 2 additions & 3 deletions
> testing/python/fixtures.py: 8 additions
> ```
>
> Key Changes
> Doctest Improvements
>
> ```
> Simplified the setup() method in DoctestItem class.
> Explicit type hinting is now available for various function parameters.
> Removed the _setup_fixtures method as it was redundant after the refactoring.
> ```
>
> Fixture Enhancements
>
> ```
> Improved type hinting for function parameters.
> The function getfixtureinfo() has been optimized to handle None values for function parameters.
> Changed the data type for parametrize_argnames from List[str] to Set[str] for better performance.
> Added deduplicate_names() function to remove duplicate names while preserving order.
> ```
>
> Miscellaneous
>
> ```
> Updated some parts of the code to be more Pythonic and straightforward.
> ```
>
> Testing
>
> Tests were added to confirm the functionality of deduplicating names in fixtures.
> Backwards Compatibility
>
> The changes are mostly internal and shouldn't affect the public API, maintaining backward compatibility.
> Additional Notes
>
> This PR is a part of an ongoing effort to improve pytest's code quality and maintainability.
>
> Please review and provide any feedback for further improvements.

This produces a much richer description than I would for such a small PR and it took almost no effort. You can clearly see that there are some parts you wouldn't want to include such as listing the files changed, possibly info on tests. It can also sometimes give its own ideas on future work, obviously you will ignore that most of the time.
Another gotcha to look out for is for very small PRs. GPT loves to pad out PRs with crap, such as "Added import for re module" You will either need to cut these out or adjust your prompt. 

A free bonus tip that works half the time is to ask for the response in a copy-pastable markdown format. Ideal for GitHub, GitLab, etc.

### Turning Classes Into Fixtures and Mock Data

I used to love testing, but over time the magic wore off and it became inane and boring, just like every other task you complete over and over and over... One of the worst parts for me is creating fixtures for integration, system and end to end tests. While there are some nice libraries that allow you to quickly write code to auto generate dummy data (such as faker), sometimes you just need something simple and you need it now. 

#### How I do this

Very simple workflow, give chatgpt a class or model definition, and ask for your desired format back.

#### Another Example

The prompt:

> I want you to generate me 4 json objects that I can use in a json file, made up of dummy data based on the following class definition:
>
> ```python
> @dataclass
> class Article:
>   title: str
>   id: UUID
>   keywords: List[str]
>   word_count: int
> ```

And the response we we get:

```JavaScript
[
  {
    "title": "Exploring the Deep Ocean",
    "id": "58ebd71f-a440-4f89-8df3-7692e38804de",
    "keywords": ["ocean", "exploration", "marine biology"],
    "word_count": 1500
  },
  {
    "title": "The History of Coffee",
    "id": "96178b90-8baf-47d7-9882-164690c9de6a",
    "keywords": ["coffee", "history", "beverage"],
    "word_count": 1800
  },
  {
    "title": "Understanding Quantum Mechanics",
    "id": "d2d33cfc-2d8c-4a2d-a8a7-19e04a3d8b15",
    "keywords": ["quantum mechanics", "physics", "science"],
    "word_count": 2100
  },
  {
    "title": "The Impact of Climate Change",
    "id": "5ce40f15-5a92-41c3-935e-e9293d2f580a",
    "keywords": ["climate change", "environment", "global warming"],
    "word_count": 2300
  }
]
```

This is rapid in comparison to the pre-LLM days of writing something quick and dirty. The data is coherent, easy to change, and it understood what a UUID was. We could generate more items or less depending on our needs.

### Generating Simple Code and Tests

While some people will tell you that dev work is dead and we can all be replaced with AI, I am not so sure. I have seen some terrible output from GPT4 when you ask for something that hasn't been solved before, or something that requires real thought. Simple code, complete with tests? It's excellent at that with guidance.

#### Example

First we give a very perscriptive prompt:

> I need to write a type hinted python function that takes a str as it's argument. The function will then find the substring of this form `event_<year>_<number>` where number is an int and so is year.
> It will then return the substring, but if no match is found it will raise an `IngestError` detailing the input and how no match was found. Generate this.

And we get back a nice response to take snippets from.

```python
import re
from typing import Union

class IngestError(Exception):
    pass

def find_event_substring(s: str) -> str:
    pattern = r'event_\d{4}_\d+'
    match = re.search(pattern, s)
    
    if match:
        return match.group(0)
    else:
        raise IngestError(f"Input '{s}' does not contain a valid 'event_<year>_<number>' substring.")

# Test the function
try:
    result = find_event_substring("Here is a event_2021_45 in the string.")
    print("Match found:", result)
except IngestError as e:
    print(e)

try:
    result = find_event_substring("No event substring here.")
    print("Match found:", result)
except IngestError as e:
    print(e)
```

Obviously we don't want the crap test at the bottom, we handle our own imports, and define our own exceptions, so we are likely to just grab the function, and do some renaming.

In reality I would also ask chatGPT to regenerate this with a docstring, but as this is only an example, I won't today.

Now we want some simple unit tests, so we ask for them.

> generate me some pytest unit tests for the above function

And we get them back. Here's the response, minus the waffle about installing pytest and creating test files:

```python
import pytest
from my_module import find_event_substring, IngestError

# Test with valid event string
def test_valid_event_string():
    input_str = "Here is a event_2021_45 in the string."
    assert find_event_substring(input_str) == "event_2021_45"

# Test with multiple valid event strings
def test_multiple_valid_event_strings():
    input_str = "Here are multiple event_2021_45 event_2022_33."
    assert find_event_substring(input_str) == "event_2021_45"

# Test with invalid year
def test_invalid_year():
    input_str = "Invalid year event_21_45."
    with pytest.raises(IngestError) as e_info:
        find_event_substring(input_str)
    assert str(e_info.value) == "Input 'Invalid year event_21_45.' does not contain a valid 'event_<year>_<number>' substring."

# Test with missing number
def test_missing_number():
    input_str = "Missing number event_2021_."
    with pytest.raises(IngestError) as e_info:
        find_event_substring(input_str)
    assert str(e_info.value) == "Input 'Missing number event_2021_.' does not contain a valid 'event_<year>_<number>' substring."

# Test with no event string
def test_no_event_string():
    input_str = "No event string here."
    with pytest.raises(IngestError) as e_info:
        find_event_substring(input_str)
    assert str(e_info.value) == "Input 'No event string here.' does not contain a valid 'event_<year>_<number>' substring."
```

Again this is a decent response. I think the key takeaway from this section is when you want ChatGPT to write code, you need to be as specific as possible in a lot of cases. For example we could easily improve the test formats, get docstrings automatically the first time, stick to naming conventions, if we had simply given an example and asked for the style to stay consistent with it.

### Giving Insightful Code Review to Junior Developers

One part of the job that some people love and some people loathe is helping the more junior developers. There is a trade-off between giving them lots of help and detail, and getting on with your own workload.
Luckily you can offload a lot of initial help and review to GPT.

#### A Contrived Example

Consider you are reviewing some work by a junior and come across the following code:

```python
class Inventory:
    def check_stock(self, item_id):
        print(f"Checking stock for item {item_id}")
        return True

class Payment:
    def process_payment(self, user_id, amount):
        print(f"Processed payment of {amount} for user {user_id}")
        
class Shipping:
    def ship_item(self, item_id, address):
        print(f"Shipping item {item_id} to {address}")

# Client code
inventory = Inventory()
payment = Payment()
shipping = Shipping()

if inventory.check_stock("ABC123"):
    payment.process_payment("user1", 100)
    shipping.ship_item("ABC123", "123 Main St")
```

Obviously not in the same place, but this is a contrived example after all. As an experienced developer you see the problem, but are currently too busy to give an in depth review, and it might not be as effective to simply request changes with a 1 sentence comment "Look at facade pattern".

Once again here comes ChatGPT to the resuce.

> The prompt:
>
> A junior dev has written the below code, I am reviewing it and think it could benefit from facade pattern, generate me a review comment that gives a simple explanation of the facade pattern, and how it could be used to simplify the below code with a `place_order` function or method as part of a larger facade:
> <Copy and paste of above code>
>
> And we get back:
> The code you've written certainly works, but it requires the client code to interact with multiple subsystems (Inventory, Payment, Shipping) directly to complete a single operation: placing an order. This can make the code harder to manage and extend in the future.
>
> Consider using the Facade Pattern to simplify this. The Facade Pattern provides a unified interface to a set of interfaces in a subsystem, making it easier to interact with the subsystem as a whole. Essentially, it wraps several complex subsystems behind a single, simplified API. This makes it easier to maintain, easier to read, and reduces the dependencies between the subsystems and the client code.
>
> For instance, you could create a OrderFacade class that includes a place_order function, like this:
>
> ```python
> class OrderFacade:
>     def __init__(self):
>         self.inventory = Inventory()
>         self.payment = Payment()
>         self.shipping = Shipping()
>
>     def place_order(self, item_id, user_id, amount, address):
>         if self.inventory.check_stock(item_id):
>             self.payment.process_payment(user_id, amount)
>             self.shipping.ship_item(item_id, address)
> ```
>
> Then, your client code could be simplified to:
>
> ```python
> order_facade = OrderFacade()
> order_facade.place_order("ABC123", "user1", 100, "123 Main St")
> ```
>
> By doing this, you encapsulate the complexities and dependencies in a single class, making it easier to manage.
>
> Then we can skim the response, make sure it's correct, edit it slightly and post it. Obviously we don't want to secretly bypass ourselves when we inevitably get follow up questions, but by telling ChatGPT what we want explained, the context of the review, and the solution we are aiming towards, we can help a lot more in a much shorter time. 

### Concluding Thoughts

Lots of people like to talk about how good GPT is at coding, overestimating its abilities, and although we have shown it can be very effective with strict guidance, I believe the greatest strengths of ChatGPT lie in every other aspect of software engineering. 

There are many more ways in which I can, and do, leverage the power of ChatGPT, such as turning User Stories into Gherkin Syntax Scenarios, interpreting test failure assertion errors, Pretty printing json that has errors, but this post would never end. However, if you feel you have some truly novel uses please email me (link below).

How to Boost Your Software Development Workflow with ChatGPT-4: 4 Practical Use Cases



When you interact with ChatGPT, whether you're seeking answers to questions, requesting document generation, code snippets, or any other kind of assistance, it's all too easy to get tunnel vision. You might zero in on specific points, themes, or concepts, unintentionally ignoring other aspects that could be equally helpful or enlightening. In other words, there are likely angles or perspectives you haven't even thought of exploring.



Many people approach ChatGPT as a one-way tool, a sort of "black box" where you feed in your input and await a generated output. They overlook the platform's capacity for interactive dialogue, missing out on the opportunity to have a more fluid, back-and-forth exchange that could enrich the end result. ChatGPT is more than just a generation tool; it can actively participate in shaping and refining the conversation or project at hand.



One technique I've coined—aptly or not—as "Prompt Inversion" can be particularly useful for this. (And hey, I don't claim to be an expert who pores over all the literature on AI, machine learning models, and the like, so forgive me if the term is already in use for something else.)



Let's go through an example below:

### Example

In this completely contrived scenario I need to write approximately 150 words about my past year.

#### The Classic Question

It's very easy to write something like this.

> User
>
> I need to write a 150 word section on my last year of life. For context I am a software engineer, I have settled into my new job, I have tried to get into blogging, and am looking at starting freelancing. I am still saving to buy a home
>
>
>
> Generate it please

This prompt is the classic treatment, I know what I need, and I think I know what information is needed to get what I need. Typical input, output black box. Here is the response:

> Over the past year, my life has been a blend of stability and growth, both professionally and personally. As a Software Engineer, I've settled into my new role, taking on complex projects that not only pushed my technical skills but also honed my ability to collaborate within a team. My job has become a satisfying part of my daily routine, and I've grown more confident in my expertise.
>
>
>
> In addition to my 9-to-5, I dipped my toes into the world of blogging. This journey of sharing my knowledge and insights about software development has been enlightening, allowing me to reflect on my own practices while engaging with a wider audience. The process has been both rewarding and challenging, revealing gaps in my understanding and fueling my curiosity to learn more.
>
>
>
> Exploring the potential of freelancing has also been a focal point. The idea of diversifying my income and skillset has always appealed to me, and this year I've taken steps to make that vision a reality. Meanwhile, I've been diligently saving for a future home, a milestone I eagerly look forward to. All in all, it's been a year of laying the foundation for bigger things to come.

This response is ok. I didn't give it much info to go on, so it started filling in the blanks by adding assumptions, such as "reflecting on my own practices with a wider audience." A reasonable guess, but I don't actually expect anyone to read this blog.



#### The Inverted Prompt

Now let's look at how we can include ChatGPT into the workflow and get more ideas for our output therefore unconstraining our output from our own limited imagination.

> I need to write 150 word section on the last year of my life. Please devise a questionaire that you can use to find out about me, then use my answers to generate the section

Our initial prompt is asking for a series of questions for us to answer. Here's what we get back.

> Absolutely, I'd be happy to help. Here's a questionnaire to help me gather some key information about the last year of your life:
>
>
>
> \    What major life events have occurred in the last year? (E.g., graduation, new job, marriage, etc.)
>
> \    Have you moved or traveled significantly?
>
> \    Have you achieved any personal or professional milestones?
>
> \    Were there any major challenges or obstacles you faced? How did you overcome them?
>
> \    Did you take up any new hobbies or interests?
>
> \    What significant relationships have you formed or developed over the past year?
>
> \    How has your perspective or outlook on life changed, if at all?
>
> \    Have you made any meaningful contributions to your community or to any causes you care about?
>
> \    Were there any moments that you felt were particularly transformative?
>
> \    Is there a particular theme or lesson that encapsulates your experiences from the last year?
>
>
>
> Please answer these questions, and then I'll use your responses to generate a 150-word section about the last year of your life.

Interesting, it's already clear we could end up with a much richer summary, I never considered relationships, outlook on life, etc. when I thought I knew what to include. Now we answer this questionaire.

> 1. I have settled into my new job and am still a fullstack software engineer
>
> 2. I have not moved but am still saving for a home and getting closer to affording a deposit
>
> 3. I am actually going for a promotion this month.
>
> 4. N/A
>
> 5. I have started blogging and wanting to get started with freelancing
>
> 6. My relationships are stable but I am going to propose this year
>
> 7. I have a positive outlook on my personal life but a negative outlook on the UK as a whole at the moment.
>
> 8. N/A
>
> 9. I am enjoying taking the lead more at work
>
> 10. I am trying to expand my activities and unshackle myself from only having a 9-5 job

It is smart enough to handle us not answering some questions, and we get our new section.

> Over the past year, I've deepened my roots in my career as a full-stack software engineer while eyeing the horizon for new opportunities. Notably, a promotion looms on my near-future calendar, an achievement that would mark a key professional milestone. Concurrently, I've inched closer to affording a home, fortifying both my financial stability and future planning.
>
>
>
> While content in my career, my aspirations extend beyond the 9-to-5 grind. I've plunged into the world of blogging and am exploring the possibilities of freelancing, broadening my skill set and outreach. On the personal front, this year holds the promise of significant change; I plan to propose, solidifying a relationship that has remained a stable cornerstone in my life.
>
>
>
> Despite personal accomplishments and a generally optimistic outlook, I harbor reservations about the direction the UK is taking—a sentiment that has only intensified over the last year. Nevertheless, I find fulfillment in gradually assuming leadership roles at work and am actively working to diversify my life's portfolio, pursuing activities that enrich me beyond my primary profession.



Now let's compare our 2 sections.

Both responses provide information about the year's events but in slightly different ways. The inverted prompt response offers more breadth and depth primarily because it is written with more information and context. This allows it to present a fuller picture of the individual's experiences, encompassing both tangible and intangible aspects of life. Unlike a narrative that might fill in gaps or make assumptions, this approach enables the text to delve deeper into specific events, future aspirations, and emotional undertones. By incorporating a broader range of topics and adding layers of detail and nuance, the inverted prompt response provides a more comprehensive and informative account of the past year.



### The Takeaway

By treating ChatGPT as a collaborative tool rather than just a 'black box,' you can unlock a far more layered, comprehensive, and authentic narrative. Whether it's a blog post, an essay, or any other form of project, incorporating this method of "Prompt Inversion" can take your output from just adequate to truly reflective of your requirements.

Prompt Inversion: Prompt You to Prompt Me

Ah, the allure of horoscopes! Who doesn't love being told that they're "entering a phase of great personal growth" or that they should "avoid making any big decisions during the Mercury retrograde?" Horoscopes have fascinated mankind for centuries, offering a daily dose of cryptic, yet oddly resonating, life advice.

But what's the magic behind horoscopes? How can they seemingly pinpoint the unique experiences and feelings we're going through? The answer lies in the art of Barnum statements.


## What Are Barnum Statements?

Barnum statements are generic and broad phrases designed to resonate with a large number of people. In other words, they're statements so universally applicable that almost anyone would find them accurate or enlightening. This is the secret sauce that makes horoscopes so captivating.
Some Classic Examples:

```
"You have a strong desire for a better life, yet often feel overwhelmed by obstacles."
"You have a great deal of unused capacity that you have not yet turned to your advantage."
"While you have some personality weaknesses, you are generally able to compensate for them."
```

These statements could apply to just about anyone on the planet, but when read in the context of a personalized horoscope, they suddenly feel like the celestial bodies have aligned just to give you some tailored life advice.
Becoming Terrible at Code Reviews Using Barnum Statements

Now, the time has come to apply this ancient wisdom to a sacred art that has perplexed many a developer: the code review. How can you, too, become terrible at this esteemed practice? Just apply the principle of Barnum statements to your comments! Here's how you can do it:


## The Top 10 Barnum Statements for Code Reviews:

```
"Great effort, but this code could benefit from a bit more optimization."
    Applicable in any scenario. Optimization is always a goal, isn't it?

"This code is mostly clean and clear, but it might be helpful to add a few more comments for better readability."
    Who doesn't love comments?

"The functionality is there, but have you considered making it more modular?"
    Ah, modularity, the panacea for all coding woes.

"The code works as expected, but it seems like there are some opportunities for refactoring."
    Refactoring: a programmer's eternal quest.

"Solid job on getting this to work! I feel like the implementation could be a bit more efficient though."
    Efficiency is always in style.

"The structure looks good, but I think the variable naming could be more descriptive."
    A classic. You can never go wrong with harping on variable names.

"Your logic is sound, but how would this scale with larger datasets?"
    Because scalability is a concern that every piece of code could potentially face.

"Nice job! I wonder if there's a way to make this code more reusable?"
    Reusability: a timeless concept.

"This is almost perfect; it just needs a few tweaks to really shine."
    "A few tweaks" is purposely vague, making this a perfect Barnum statement.

"You've clearly put in a lot of work here, but it might help to double-check for edge cases."
    Edge cases: the ever-elusive bogeymen of coding.
```

Using these statements in your code reviews, you'll create an atmosphere of vagueness and generalization that can drive any team to the edge of coding insanity. Soon enough, your peers will look at your comments the way people look at their daily horoscopes: with a sense of skepticism but a tiny hope that they might actually mean something.

So, if you've ever dreamt of being a less-than-stellar code reviewer while imbuing your reviews with an air of celestial mystique, now's your chance. Embrace the Barnum statement, and let the stars guide you to code review mediocrity.

Disclaimer: This post is tongue-in-cheek. Quality code reviews are crucial for effective teamwork and codebase maintenance. Please do not actually use Barnum statements for code reviews. Unless, of course, you want to become the subject of your team's next retro.