### 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.