The Hierarchy of Webapp Needs - idmontie's Portfolio

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    img: "img",
    strong: "strong",
    h3: "h3",
    ul: "ul",
    li: "li",
    a: "a"
  }, props.components), {Mermaid} = _components;
  if (!Mermaid) _missingMdxReference("Mermaid", true);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: _jsx(_components.img, {
        src: "/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.57.30_PM.png",
        alt: "Screen Shot 2023-01-07 at 3.57.30 PM.png"
      })
    }), "\n", _jsx(_components.p, {
      children: "While working on Clarity Hub, we created a Clarity Hub Infer API along with a developer portal that would let anyone create infer models."
    }), "\n", _jsx(_components.p, {
      children: "The Clarity Hub Infer API provides a fast and intuitive way to create, manage, and deploy NLP models based on labelling utterances."
    }), "\n", _jsx(_components.p, {
      children: "At the most basic level, the Infer API would let users send utterances via an API and get toxicity analysis, sentiment scores, and simple NLP data like nouns and topics from the utterances."
    }), "\n", _jsx(_components.p, {
      children: "The power of the Infer API is that consumers can supply a set of pre-labelled utterances to the API, and the API will create a model from this, even if there are only a few utterances used for training. Then the consumer can send a new utterance get a label using that model."
    }), "\n", _jsx(_components.p, {
      children: "The NLP APIs at Clarity Hub were a set of APIs:"
    }), "\n", _jsx(Mermaid, {
      chart: "graph RL\n  NLP(Clarity Hub NLP API) --> API(Clarity Hub Infer API) --> Consumer"
    }), "\n", _jsx(_components.p, {
      children: "The Consumer would user the Infer API which provided APIs for training and labeling datasets and getting toxicity and sentiment analyses. the Clarity Hub NLP API contained trained Tensorflow datasets for creating embeddings via the Universal Sentence Encoder (USE)."
    }), "\n", _jsxs(_components.p, {
      children: ["An ", _jsx(_components.strong, {
        children: "embedding"
      }), " a vector that represents an utterance - a sentence, sentence fragment, or paragraph of text."]
    }), "\n", _jsx(_components.p, {
      children: "Training would involve a consumer sending a payload of utterances with labels to the Infer API, which would call the NLP API internally to create embeddings. We then clustered these embeddings to and re-labelled the clusters using the given labels. If no label was found for an utterance cluster, we attempted to pull a topic out of the utterances to re-label it."
    }), "\n", _jsx(_components.p, {
      children: "The clusters with labels were then stored into S3."
    }), "\n", _jsx(Mermaid, {
      chart: "graph TD\n  Train -->|Utterances with labels| USE\n  USE -->|Embeddings with labels| Clustering\n  Clustering -->|Embedding Clusters| Labeller\n  Labeller -->|Clusters with Labels| S3"
    }), "\n", _jsx(_components.p, {
      children: "To classify a new utterance, we created an embedding from it, loaded the existing dataset in, then ran cosine similarity to find the most probabilistic matches:"
    }), "\n", _jsx(Mermaid, {
      chart: "graph TD\n  Classify --> |Utterance| USE\n  USE --> |Embedding| Classifier(Classifier)\n  Classifier --> |Embedding + Clusters from S3| Similarity(Cosine Similarity)\n  Similarity --> |Labels with Probability| Response"
    }), "\n", _jsx(_components.h3, {
      children: "What it looked like"
    }), "\n", _jsx(_components.p, {
      children: _jsx(_components.img, {
        src: "/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.57.56_PM.png",
        alt: "Screen Shot 2023-01-07 at 3.57.56 PM.png"
      })
    }), "\n", _jsx(_components.p, {
      children: _jsx(_components.img, {
        src: "/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.58.08_PM.png",
        alt: "Screen Shot 2023-01-07 at 3.58.08 PM.png"
      })
    }), "\n", _jsx(_components.p, {
      children: _jsx(_components.img, {
        src: "/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.58.28_PM.png",
        alt: "Screen Shot 2023-01-07 at 3.58.28 PM.png"
      })
    }), "\n", _jsx(_components.h3, {
      children: "Conclusion"
    }), "\n", _jsx(_components.p, {
      children: "With ChatGPT and other NLP models coming out lately, this seems fairly basic, but the following processes are still very useful to understand:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "Convert language to a representation that is easier to work with, like a vector."
      }), "\n", _jsx(_components.li, {
        children: "Clustering vectors is a great way to find representative vectors, reducing the size of the number of vectors you need to work with."
      }), "\n", _jsx(_components.li, {
        children: "Cosine Similarity can be used to find how similar vectors are. If a vector is labelled with metadata, it also tells you how similar the metadata between the vectors are as well."
      }), "\n"]
    }), "\n", _jsxs(_components.p, {
      children: ["You can see ", _jsx(_components.a, {
        href: "/projects/2020-05-18-clarity-hub-infer",
        children: "my project page"
      }), " for more details and links to the Github repos."]
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};
function _missingMdxReference(id, component) {
  throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it.");
}


<img alt="Screen Shot 2023-01-07 at 3.57.30 PM.png" src="/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.57.30_PM.png" style="max-height:500px;margin:auto;text-align:center"/>
While working on Clarity Hub, we created a Clarity Hub Infer API along with a developer portal that would let anyone create infer models.
The Clarity Hub Infer API provides a fast and intuitive way to create, manage, and deploy NLP models based on labelling utterances.
At the most basic level, the Infer API would let users send utterances via an API and get toxicity analysis, sentiment scores, and simple NLP data like nouns and topics from the utterances.
The power of the Infer API is that consumers can supply a set of pre-labelled utterances to the API, and the API will create a model from this, even if there are only a few utterances used for training. Then the consumer can send a new utterance get a label using that model.
The NLP APIs at Clarity Hub were a set of APIs:
<div class="py-8 [&amp;_svg]:m-auto"><div class="mermaid" data-mermaid-src="graph RL
 NLP(Clarity Hub NLP API) --&gt; API(Clarity Hub Infer API) --&gt; Consumer">graph RL
 NLP(Clarity Hub NLP API) --&gt; API(Clarity Hub Infer API) --&gt; Consumer</div></div>
The Consumer would user the Infer API which provided APIs for training and labeling datasets and getting toxicity and sentiment analyses. the Clarity Hub NLP API contained trained Tensorflow datasets for creating embeddings via the Universal Sentence Encoder (USE).
An embedding a vector that represents an utterance - a sentence, sentence fragment, or paragraph of text.
Training would involve a consumer sending a payload of utterances with labels to the Infer API, which would call the NLP API internally to create embeddings. We then clustered these embeddings to and re-labelled the clusters using the given labels. If no label was found for an utterance cluster, we attempted to pull a topic out of the utterances to re-label it.
The clusters with labels were then stored into S3.
<div class="py-8 [&amp;_svg]:m-auto"><div class="mermaid" data-mermaid-src="graph TD
 Train --&gt;|Utterances with labels| USE
 USE --&gt;|Embeddings with labels| Clustering
 Clustering --&gt;|Embedding Clusters| Labeller
 Labeller --&gt;|Clusters with Labels| S3">graph TD
 Train --&gt;|Utterances with labels| USE
 USE --&gt;|Embeddings with labels| Clustering
 Clustering --&gt;|Embedding Clusters| Labeller
 Labeller --&gt;|Clusters with Labels| S3</div></div>
To classify a new utterance, we created an embedding from it, loaded the existing dataset in, then ran cosine similarity to find the most probabilistic matches:
<div class="py-8 [&amp;_svg]:m-auto"><div class="mermaid" data-mermaid-src="graph TD
 Classify --&gt; |Utterance| USE
 USE --&gt; |Embedding| Classifier(Classifier)
 Classifier --&gt; |Embedding + Clusters from S3| Similarity(Cosine Similarity)
 Similarity --&gt; |Labels with Probability| Response">graph TD
 Classify --&gt; |Utterance| USE
 USE --&gt; |Embedding| Classifier(Classifier)
 Classifier --&gt; |Embedding + Clusters from S3| Similarity(Cosine Similarity)
 Similarity --&gt; |Labels with Probability| Response</div></div>
<h3>What it looked like</h3>
<img alt="Screen Shot 2023-01-07 at 3.57.56 PM.png" src="/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.57.56_PM.png" style="max-height:500px;margin:auto;text-align:center"/>
<img alt="Screen Shot 2023-01-07 at 3.58.08 PM.png" src="/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.58.08_PM.png" style="max-height:500px;margin:auto;text-align:center"/>
<img alt="Screen Shot 2023-01-07 at 3.58.28 PM.png" src="/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.58.28_PM.png" style="max-height:500px;margin:auto;text-align:center"/>
<h3>Conclusion</h3>
With ChatGPT and other NLP models coming out lately, this seems fairly basic, but the following processes are still very useful to understand:
<ul>
<li>Convert language to a representation that is easier to work with, like a vector.</li>
<li>Clustering vectors is a great way to find representative vectors, reducing the size of the number of vectors you need to work with.</li>
<li>Cosine Similarity can be used to find how similar vectors are. If a vector is labelled with metadata, it also tells you how similar the metadata between the vectors are as well.</li>
</ul>
You can see <a href="/projects/2020-05-18-clarity-hub-infer">my project page</a> for more details and links to the Github repos.


![Screen Shot 2023-01-07 at 3.57.30 PM.png](/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.57.30_PM.png)

While working on Clarity Hub, we created a Clarity Hub Infer API along with a developer portal that would let anyone create infer models.

The Clarity Hub Infer API provides a fast and intuitive way to create, manage, and deploy NLP models based on labelling utterances.

At the most basic level, the Infer API would let users send utterances via an API and get toxicity analysis, sentiment scores, and simple NLP data like nouns and topics from the utterances.

The power of the Infer API is that consumers can supply a set of pre-labelled utterances to the API, and the API will create a model from this, even if there are only a few utterances used for training. Then the consumer can send a new utterance get a label using that model.

The NLP APIs at Clarity Hub were a set of APIs:

```mermaid
graph RL
  NLP(Clarity Hub NLP API) --> API(Clarity Hub Infer API) --> Consumer
```

The Consumer would user the Infer API which provided APIs for training and labeling datasets and getting toxicity and sentiment analyses. the Clarity Hub NLP API contained trained Tensorflow datasets for creating embeddings via the Universal Sentence Encoder (USE).

An **embedding** a vector that represents an utterance - a sentence, sentence fragment, or paragraph of text.

Training would involve a consumer sending a payload of utterances with labels to the Infer API, which would call the NLP API internally to create embeddings. We then clustered these embeddings to and re-labelled the clusters using the given labels. If no label was found for an utterance cluster, we attempted to pull a topic out of the utterances to re-label it.

The clusters with labels were then stored into S3.

```mermaid
graph TD
  Train -->|Utterances with labels| USE
  USE -->|Embeddings with labels| Clustering
  Clustering -->|Embedding Clusters| Labeller
  Labeller -->|Clusters with Labels| S3
```

To classify a new utterance, we created an embedding from it, loaded the existing dataset in, then ran cosine similarity to find the most probabilistic matches:

```mermaid
graph TD
  Classify --> |Utterance| USE
  USE --> |Embedding| Classifier(Classifier)
  Classifier --> |Embedding + Clusters from S3| Similarity(Cosine Similarity)
  Similarity --> |Labels with Probability| Response
```

### What it looked like

![Screen Shot 2023-01-07 at 3.57.56 PM.png](/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.57.56_PM.png)

![Screen Shot 2023-01-07 at 3.58.08 PM.png](/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.58.08_PM.png)

![Screen Shot 2023-01-07 at 3.58.28 PM.png](/media/2023-01-07-clarity-hub-infer/Screen_Shot_2023-01-07_at_3.58.28_PM.png)

### Conclusion

With ChatGPT and other NLP models coming out lately, this seems fairly basic, but the following processes are still very useful to understand:

- Convert language to a representation that is easier to work with, like a vector.
- Clustering vectors is a great way to find representative vectors, reducing the size of the number of vectors you need to work with.
- Cosine Similarity can be used to find how similar vectors are. If a vector is labelled with metadata, it also tells you how similar the metadata between the vectors are as well.

You can see [my project page](/projects/2020-05-18-clarity-hub-infer) for more details and links to the Github repos.


Clarity Hub Infer API

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = Object.assign({
    p: "p",
    ul: "ul",
    li: "li"
  }, props.components);
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "I was thinking about all the little projects I work on and how they grow over time. The applications end up hitting some milestones and end up needing similar functionality that compliments the core features. A small project ends up getting complex enough that it requires some unit tests. I’ll go to deploy the project and now I need some deployment scripts and analytics to ensure the application is running correctly. The technology may change between each project, but web applications always seem to have the same steps that need to be taken to strengthen the application as it is scaled up."
    }), "\n", _jsx(_components.p, {
      children: "At a large company, adding a new set of functionality always has a suite of concerns to think through before implementation: how will we deploy this feature, how do we validate that users are using the feature like we expected them to, how do we monitor for bugs and errors? This is on top of the basic functionality of actually writing and testing that new feature."
    }), "\n", _jsx(_components.p, {
      children: "What if we thought about this like Maslow’s Hierarchy of Needs, but in the context of a web application."
    }), "\n", _jsx(_components.p, {
      children: "Maslow's Hierarchy of Needs is a psychological model of human motivation proposed by Abraham Maslow in 1943. The model describes a hierarchy of human needs, beginning with basic physiological needs such as food and shelter and progressing upwards to higher-level needs such as self-actualization. Maslow argued that as humans satisfy their basic needs, they can move on to satisfy their higher-level needs."
    }), "\n", _jsx(_components.p, {
      children: "Applying Maslow's Hierarchy of Needs to web applications, we can identify the different levels of needs that need to be met in order to make a web application successful."
    }), "\n", _jsx(_components.p, {
      children: "Basic functionality:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "A single build/run script"
      }), "\n", _jsx(_components.li, {
        children: "Basic functionality (e.g. CRUD operations for a web app)"
      }), "\n", _jsx(_components.li, {
        children: "User interface (e.g. layout, navigation, responsive design)"
      }), "\n", _jsx(_components.li, {
        children: "Integration with external services (e.g. databases, APIs)"
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Safety and security:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "Linting (e.g. ESLint, Prettier)"
      }), "\n", _jsx(_components.li, {
        children: "Unit tests (e.g. Jest, Mocha)"
      }), "\n", _jsx(_components.li, {
        children: "Basic error handling and reporting (e.g. logging, alerting)"
      }), "\n", _jsx(_components.li, {
        children: "Input validation (e.g. form validation)"
      }), "\n", _jsx(_components.li, {
        children: "Security best practices (e.g. encryption, password hashing, session management)"
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Love and belonging:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "Basic analytics (e.g. page views, user engagement)"
      }), "\n", _jsx(_components.li, {
        children: "User authentication and authorization (e.g. sign-up, login, role-based access control)"
      }), "\n", _jsx(_components.li, {
        children: "User feedback (e.g. contact form, survey)"
      }), "\n", _jsx(_components.li, {
        children: "Social media integration (e.g. sharing, commenting)"
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Esteem:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "Advanced analytics (e.g. user behavior tracking, A/B testing)"
      }), "\n", _jsx(_components.li, {
        children: "Performance monitoring (e.g. load testing, monitoring of server resources)"
      }), "\n", _jsx(_components.li, {
        children: "User experience optimization (e.g. user testing, usability analysis)"
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Self-actualization:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "End-to-end testing (e.g. Selenium, Cypress)"
      }), "\n", _jsx(_components.li, {
        children: "Accessibility and internationalization (e.g. support for screen readers, translation)"
      }), "\n", _jsx(_components.li, {
        children: "Scalability (e.g. load balancing, caching)"
      }), "\n", _jsx(_components.li, {
        children: "Continuous integration and delivery (e.g. Jenkins, Travis CI)"
      }), "\n", _jsx(_components.li, {
        children: "Deployment (e.g. Docker, Kubernetes)"
      }), "\n", _jsx(_components.li, {
        children: "Automated testing (e.g. unit test, integration test)"
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Of course this list isn’t exhaustive, but I’ve been thinking about it as more of a checklist to build upon when working on small side-projects that end up getting significant attention and development time."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
    children: _jsx(_createMdxContent, props)
  })) : _createMdxContent(props);
}
return {
  default: MDXContent
};


I was thinking about all the little projects I work on and how they grow over time. The applications end up hitting some milestones and end up needing similar functionality that compliments the core features. A small project ends up getting complex enough that it requires some unit tests. I’ll go to deploy the project and now I need some deployment scripts and analytics to ensure the application is running correctly. The technology may change between each project, but web applications always seem to have the same steps that need to be taken to strengthen the application as it is scaled up.
At a large company, adding a new set of functionality always has a suite of concerns to think through before implementation: how will we deploy this feature, how do we validate that users are using the feature like we expected them to, how do we monitor for bugs and errors? This is on top of the basic functionality of actually writing and testing that new feature.
What if we thought about this like Maslow’s Hierarchy of Needs, but in the context of a web application.
Maslow&#x27;s Hierarchy of Needs is a psychological model of human motivation proposed by Abraham Maslow in 1943. The model describes a hierarchy of human needs, beginning with basic physiological needs such as food and shelter and progressing upwards to higher-level needs such as self-actualization. Maslow argued that as humans satisfy their basic needs, they can move on to satisfy their higher-level needs.
Applying Maslow&#x27;s Hierarchy of Needs to web applications, we can identify the different levels of needs that need to be met in order to make a web application successful.
Basic functionality:
<ul>
<li>A single build/run script</li>
<li>Basic functionality (e.g. CRUD operations for a web app)</li>
<li>User interface (e.g. layout, navigation, responsive design)</li>
<li>Integration with external services (e.g. databases, APIs)</li>
</ul>
Safety and security:
<ul>
<li>Linting (e.g. ESLint, Prettier)</li>
<li>Unit tests (e.g. Jest, Mocha)</li>
<li>Basic error handling and reporting (e.g. logging, alerting)</li>
<li>Input validation (e.g. form validation)</li>
<li>Security best practices (e.g. encryption, password hashing, session management)</li>
</ul>
Love and belonging:
<ul>
<li>Basic analytics (e.g. page views, user engagement)</li>
<li>User authentication and authorization (e.g. sign-up, login, role-based access control)</li>
<li>User feedback (e.g. contact form, survey)</li>
<li>Social media integration (e.g. sharing, commenting)</li>
</ul>
Esteem:
<ul>
<li>Advanced analytics (e.g. user behavior tracking, A/B testing)</li>
<li>Performance monitoring (e.g. load testing, monitoring of server resources)</li>
<li>User experience optimization (e.g. user testing, usability analysis)</li>
</ul>
Self-actualization:
<ul>
<li>End-to-end testing (e.g. Selenium, Cypress)</li>
<li>Accessibility and internationalization (e.g. support for screen readers, translation)</li>
<li>Scalability (e.g. load balancing, caching)</li>
<li>Continuous integration and delivery (e.g. Jenkins, Travis CI)</li>
<li>Deployment (e.g. Docker, Kubernetes)</li>
<li>Automated testing (e.g. unit test, integration test)</li>
</ul>
Of course this list isn’t exhaustive, but I’ve been thinking about it as more of a checklist to build upon when working on small side-projects that end up getting significant attention and development time.


I was thinking about all the little projects I work on and how they grow over time. The applications end up hitting some milestones and end up needing similar functionality that compliments the core features. A small project ends up getting complex enough that it requires some unit tests. I’ll go to deploy the project and now I need some deployment scripts and analytics to ensure the application is running correctly. The technology may change between each project, but web applications always seem to have the same steps that need to be taken to strengthen the application as it is scaled up.

At a large company, adding a new set of functionality always has a suite of concerns to think through before implementation: how will we deploy this feature, how do we validate that users are using the feature like we expected them to, how do we monitor for bugs and errors? This is on top of the basic functionality of actually writing and testing that new feature.

What if we thought about this like Maslow’s Hierarchy of Needs, but in the context of a web application.

Maslow's Hierarchy of Needs is a psychological model of human motivation proposed by Abraham Maslow in 1943. The model describes a hierarchy of human needs, beginning with basic physiological needs such as food and shelter and progressing upwards to higher-level needs such as self-actualization. Maslow argued that as humans satisfy their basic needs, they can move on to satisfy their higher-level needs.

Applying Maslow's Hierarchy of Needs to web applications, we can identify the different levels of needs that need to be met in order to make a web application successful.

Basic functionality:

- A single build/run script
- Basic functionality (e.g. CRUD operations for a web app)
- User interface (e.g. layout, navigation, responsive design)
- Integration with external services (e.g. databases, APIs)

Safety and security:

- Linting (e.g. ESLint, Prettier)
- Unit tests (e.g. Jest, Mocha)
- Basic error handling and reporting (e.g. logging, alerting)
- Input validation (e.g. form validation)
- Security best practices (e.g. encryption, password hashing, session management)

Love and belonging:

- Basic analytics (e.g. page views, user engagement)
- User authentication and authorization (e.g. sign-up, login, role-based access control)
- User feedback (e.g. contact form, survey)
- Social media integration (e.g. sharing, commenting)

Esteem:

- Advanced analytics (e.g. user behavior tracking, A/B testing)
- Performance monitoring (e.g. load testing, monitoring of server resources)
- User experience optimization (e.g. user testing, usability analysis)

Self-actualization:

- End-to-end testing (e.g. Selenium, Cypress)
- Accessibility and internationalization (e.g. support for screen readers, translation)
- Scalability (e.g. load balancing, caching)
- Continuous integration and delivery (e.g. Jenkins, Travis CI)
- Deployment (e.g. Docker, Kubernetes)
- Automated testing (e.g. unit test, integration test)

Of course this list isn’t exhaustive, but I’ve been thinking about it as more of a checklist to build upon when working on small side-projects that end up getting significant attention and development time.


The Hierarchy of Webapp Needs

/*@jsxRuntime automatic @jsxImportSource react*/
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
 const _components = Object.assign({
 p: "p",
 a: "a",
 em: "em",
 hr: "hr",
 pre: "pre",
 code: "code"
 }, props.components);
 return _jsxs(_Fragment, {
 children: [_jsxs(_components.p, {
 children: ["Looks like everyone is trying to discover ChatGPT’s limitations. In one article I read, the author asked whether ", _jsx(_components.a, {
 href: "https://medium.com/@theworldaccordingtocgpt/chatgpt-can-play-20-questions-7911405f7aff",
 children: "ChatGPT can play 20 questions"
 }), ". The human in this scenario tried to play 20 questions with ChatGPT, and found that they needed to guide the AI to ask questions. From my perspective, it looked more like a failure to engineer the initial prompt correctly."]
 }), "\n", _jsx(_components.p, {
 children: "I attempted to do 20 questions with ChatGPT using a different prompt:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: I would like to play a game. It's called twenty questions. You will ask me one question at a time and I will answer it. The goal is for you guess the thing I am thinking about."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Sure, I'd be happy to play \"Twenty Questions\" with you. Please go ahead and think of something, and I will start asking my first question."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: I am ready"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Great, here is my first question: Is the thing you are thinking of an object?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you can hold in your hand?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you would typically find in a kitchen?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you would use for transportation?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object something that you would use for entertainment or leisure?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a musical instrument?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a type of game or puzzle?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a piece of technology such as a phone or computer?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a book or magazine?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a novel or a collection of short stories?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object a specific book that is widely known and read?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object \"To Kill a Mockingbird\" by Harper Lee?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: No"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: I'm sorry, I'm running out of ideas. Can you give me a hint or tell me the answer?"
 })
 }), "\n", _jsx(_components.p, {
 children: "Seems like we hit a wall here with twenty questions, but ChatGPT is very close, so I decided to give a hint."
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: You are on the right track. It is by Walt Whitman"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Is the object \"Leaves of Grass\" by Walt Whitman?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Yes! Congratulations!"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Thank you! I'm glad I was able to guess the object you were thinking of. It was fun playing \"Twenty Questions\" with you. Let me know if you want to play again sometime."
 })
 }), "\n", _jsx(_components.hr, {}), "\n", _jsxs(_components.p, {
 children: ["I’ve been keeping an eye on how other people are using ChatGPT, and ", _jsx(_components.a, {
 href: "https://en.wikipedia.org/wiki/Prompt_engineering",
 children: "prompt engineering"
 }), " is one of the more fascinating aspects around how people are communicating with the AI. Prompt engineering plays a key role in communicating with models like ChatGPT. Carefully crafting prompts can help maximize the quality of the reponse. However, it is important to keep in mind that, like any AI model, ChatGPT has its own set of limitations."]
 }), "\n", _jsxs(_components.p, {
 children: ["So I was curious when I read that “", _jsx(_components.a, {
 href: "https://www.reddit.com/r/ChatGPT/comments/101e454/chatgpt_cant_write_sentences_that_end_with_a/",
 children: "ChatGPT can’t write sentences that end in a specific letter"
 }), "”. Is this a real limitation of ChatGPT, or maybe this was just a poor prompt."]
 }), "\n", _jsx(_components.p, {
 children: "So let’s start with a very simple question to ChatGPT:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you write a sentence that ends with the letter \"a\"?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The cat sat on the mat."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: That sentence does not end in the letter \"a\". Can you write a sentence that ends in the letter \"a\"?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: I can't think of anything right now, but the word \"America\" ends with letter \"a\"."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Great, write a sentence that ends in that word. That will then satisfy the original question."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The land of the free, and the home of the brave, America."
 })
 }), "\n", _jsx(_components.p, {
 children: "Okay, that does technically end in the letter a, but the sentence seems very strange."
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: That isn't a very coherent sentence. Can you write a sentence that ends in the letter \"a\"?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: I am sorry for the confusion, here is a sentence that ends with the letter \"a\" - \"He saw the drama unfold on the stage, it was quite the spectacle, a.”"
 })
 }), "\n", _jsx(_components.p, {
 children: "Looks like we are going off the rails here. Let’s try a different approach:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Write a sentence that ends in a word that ends with the letter \"a\"."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The sun was setting over the horizon, painting the sky with shades of orange and red, a spectacle to behold and end the day with."
 })
 }), "\n", _jsx(_components.p, {
 children: "I’m going to ask ChatGPT to tell me a prompt to feed back to itself. I’ve found this useful for resetting context when having long conversations. Or if ChatGPT gets into weird states like the above response."
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you tell me how to write a prompt for you that would actually get you to write a sentence that ends in the letter \"a\"."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Sure, to get me to write a sentence that ends in the letter \"a\" you could provide a prompt like: \"Write a sentence that ends with a word that ends with the letter 'a'\" or \"Can you write a sentence with a word ending in 'a' at the end of the sentence?\" . This makes it clear that the sentence should end in a word ending with the letter 'a'."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you write a sentence with a word ending in 'a' at the end of the sentence?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: The sky was clear and blue, not a cloud in sight, perfect for a day out at the parka."
 })
 }), "\n", _jsx(_components.hr, {}), "\n", _jsx(_components.p, {
 children: "While ChatGPT is great at forming sentences and even code, it seems like it has no understanding and hasn’t been trained on letters, syllables, or the concept of sentences. I've seen others get ChatGPT to create poems, but it has no concept of why words would rhyme. It can give great answers to questions, but doesn’t understand how to count how many words are in its response."
 }), "\n", _jsx(_components.p, {
 children: "One Redditor in the link above mentions that ChatGPT fails at ASCII art. I’ve tried getting the AI to print ASCII art before, and I’ll leave you with part of a conversation I’ve had with it. This appears to be the best ASCII art I could get it to print, even after having a long conversation where I provided different ASCII art examples:"
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you make ASCII art? Show me a picture of a cat."
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Sure! Here is a picture of a cat using ASCII art:"
 })
 }), "\n", _jsx(_components.pre, {
 children: _jsx(_components.code, {
 children: " /\\_/\\\n( o.o )\n >^<\n\n"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "I hope you like it! Is there anything else I can help with?"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "Me: Can you make it more detailed"
 })
 }), "\n", _jsx(_components.p, {
 children: _jsx(_components.em, {
 children: "ChatGPT: Certainly! Here is a more detailed version of an ASCII art cat:"
 })
 }), "\n", _jsx(_components.pre, {
 children: _jsx(_components.code, {
 children: " /\\_/\\\n( o.o )\n >^<\n | |\n || ||\n \\\\ //\n // \\\\\n \\\\_//\n / \\\n / \\\n\n"
 })
 }), "\n", _jsx(_components.p, {
 children: "With new language models coming out, it's important to recognize what the limitations\nof the AI are. Poor responses can be a result of poorly written prompts, but there\nare times, like with letters in words with ChatGPT, where the AI just doesn't have\nthe capability to understand the question."
 })]
 });
}
function MDXContent(props = {}) {
 const {wrapper: MDXLayout} = props.components || ({});
 return MDXLayout ? _jsx(MDXLayout, Object.assign({}, props, {
 children: _jsx(_createMdxContent, props)
 })) : _createMdxContent(props);
}
return {
 default: MDXContent
};

Looks like everyone is trying to discover ChatGPT’s limitations. In one article I read, the author asked whether <a href="https://medium.com/@theworldaccordingtocgpt/chatgpt-can-play-20-questions-7911405f7aff">ChatGPT can play 20 questions</a>. The human in this scenario tried to play 20 questions with ChatGPT, and found that they needed to guide the AI to ask questions. From my perspective, it looked more like a failure to engineer the initial prompt correctly.
I attempted to do 20 questions with ChatGPT using a different prompt:
Me: I would like to play a game. It&#x27;s called twenty questions. You will ask me one question at a time and I will answer it. The goal is for you guess the thing I am thinking about.
ChatGPT: Sure, I&#x27;d be happy to play &quot;Twenty Questions&quot; with you. Please go ahead and think of something, and I will start asking my first question.
Me: I am ready
ChatGPT: Great, here is my first question: Is the thing you are thinking of an object?
Me: Yes
ChatGPT: Is the object something that you can hold in your hand?
Me: Yes
ChatGPT: Is the object something that you would typically find in a kitchen?
Me: No
ChatGPT: Is the object something that you would use for transportation?
Me: No
ChatGPT: Is the object something that you would use for entertainment or leisure?
Me: Yes
ChatGPT: Is the object a musical instrument?
Me: No
ChatGPT: Is the object a type of game or puzzle?
Me: No
ChatGPT: Is the object a piece of technology such as a phone or computer?
Me: No
ChatGPT: Is the object a book or magazine?
Me: Yes
ChatGPT: Is the object a novel or a collection of short stories?
Me: Yes
ChatGPT: Is the object a specific book that is widely known and read?
Me: Yes
ChatGPT: Is the object &quot;To Kill a Mockingbird&quot; by Harper Lee?
Me: No
ChatGPT: I&#x27;m sorry, I&#x27;m running out of ideas. Can you give me a hint or tell me the answer?
Seems like we hit a wall here with twenty questions, but ChatGPT is very close, so I decided to give a hint.
Me: You are on the right track. It is by Walt Whitman
ChatGPT: Is the object &quot;Leaves of Grass&quot; by Walt Whitman?
Me: Yes! Congratulations!
ChatGPT: Thank you! I&#x27;m glad I was able to guess the object you were thinking of. It was fun playing &quot;Twenty Questions&quot; with you. Let me know if you want to play again sometime.
<hr/>
I’ve been keeping an eye on how other people are using ChatGPT, and <a href="https://en.wikipedia.org/wiki/Prompt_engineering">prompt engineering</a> is one of the more fascinating aspects around how people are communicating with the AI. Prompt engineering plays a key role in communicating with models like ChatGPT. Carefully crafting prompts can help maximize the quality of the reponse. However, it is important to keep in mind that, like any AI model, ChatGPT has its own set of limitations.
So I was curious when I read that “<a href="https://www.reddit.com/r/ChatGPT/comments/101e454/chatgpt_cant_write_sentences_that_end_with_a/">ChatGPT can’t write sentences that end in a specific letter</a>”. Is this a real limitation of ChatGPT, or maybe this was just a poor prompt.
So let’s start with a very simple question to ChatGPT:
Me: Can you write a sentence that ends with the letter &quot;a&quot;?
ChatGPT: The cat sat on the mat.
Me: That sentence does not end in the letter &quot;a&quot;. Can you write a sentence that ends in the letter &quot;a&quot;?
ChatGPT: I can&#x27;t think of anything right now, but the word &quot;America&quot; ends with letter &quot;a&quot;.
Me: Great, write a sentence that ends in that word. That will then satisfy the original question.
ChatGPT: The land of the free, and the home of the brave, America.
Okay, that does technically end in the letter a, but the sentence seems very strange.
Me: That isn&#x27;t a very coherent sentence. Can you write a sentence that ends in the letter &quot;a&quot;?
ChatGPT: I am sorry for the confusion, here is a sentence that ends with the letter &quot;a&quot; - &quot;He saw the drama unfold on the stage, it was quite the spectacle, a.”
Looks like we are going off the rails here. Let’s try a different approach:
Me: Write a sentence that ends in a word that ends with the letter &quot;a&quot;.
ChatGPT: The sun was setting over the horizon, painting the sky with shades of orange and red, a spectacle to behold and end the day with.
I’m going to ask ChatGPT to tell me a prompt to feed back to itself. I’ve found this useful for resetting context when having long conversations. Or if ChatGPT gets into weird states like the above response.
Me: Can you tell me how to write a prompt for you that would actually get you to write a sentence that ends in the letter &quot;a&quot;.
ChatGPT: Sure, to get me to write a sentence that ends in the letter &quot;a&quot; you could provide a prompt like: &quot;Write a sentence that ends with a word that ends with the letter &#x27;a&#x27;&quot; or &quot;Can you write a sentence with a word ending in &#x27;a&#x27; at the end of the sentence?&quot; . This makes it clear that the sentence should end in a word ending with the letter &#x27;a&#x27;.
Me: Can you write a sentence with a word ending in &#x27;a&#x27; at the end of the sentence?
ChatGPT: The sky was clear and blue, not a cloud in sight, perfect for a day out at the parka.
<hr/>
While ChatGPT is great at forming sentences and even code, it seems like it has no understanding and hasn’t been trained on letters, syllables, or the concept of sentences. I&#x27;ve seen others get ChatGPT to create poems, but it has no concept of why words would rhyme. It can give great answers to questions, but doesn’t understand how to count how many words are in its response.
One Redditor in the link above mentions that ChatGPT fails at ASCII art. I’ve tried getting the AI to print ASCII art before, and I’ll leave you with part of a conversation I’ve had with it. This appears to be the best ASCII art I could get it to print, even after having a long conversation where I provided different ASCII art examples:
Me: Can you make ASCII art? Show me a picture of a cat.
ChatGPT: Sure! Here is a picture of a cat using ASCII art:
<div class="overflow-auto rounded bg-gray-200 p-4 font-mono text-sm dark:bg-gray-800 dark:text-gray-100"><pre><code> /\_/\
( o.o )
 &gt;^&lt;

</code></pre></div>
I hope you like it! Is there anything else I can help with?
Me: Can you make it more detailed
ChatGPT: Certainly! Here is a more detailed version of an ASCII art cat:
<div class="overflow-auto rounded bg-gray-200 p-4 font-mono text-sm dark:bg-gray-800 dark:text-gray-100"><pre><code> /\_/\
( o.o )
 &gt;^&lt;
 | |
 || ||
 \\ //
 // \\
 \\_//
 / \
 / \

</code></pre></div>
With new language models coming out, it&#x27;s important to recognize what the limitations
of the AI are. Poor responses can be a result of poorly written prompts, but there
are times, like with letters in words with ChatGPT, where the AI just doesn&#x27;t have
the capability to understand the question.

Looks like everyone is trying to discover ChatGPT’s limitations. In one article I read, the author asked whether [ChatGPT can play 20 questions](https://medium.com/@theworldaccordingtocgpt/chatgpt-can-play-20-questions-7911405f7aff). The human in this scenario tried to play 20 questions with ChatGPT, and found that they needed to guide the AI to ask questions. From my perspective, it looked more like a failure to engineer the initial prompt correctly.

I attempted to do 20 questions with ChatGPT using a different prompt:

*Me: I would like to play a game. It's called twenty questions. You will ask me one question at a time and I will answer it. The goal is for you guess the thing I am thinking about.*

*ChatGPT: Sure, I'd be happy to play "Twenty Questions" with you. Please go ahead and think of something, and I will start asking my first question.*

*Me: I am ready*

*ChatGPT: Great, here is my first question: Is the thing you are thinking of an object?*

*Me: Yes*

*ChatGPT: Is the object something that you can hold in your hand?*

*Me: Yes*

*ChatGPT: Is the object something that you would typically find in a kitchen?*

*Me: No*

*ChatGPT: Is the object something that you would use for transportation?*

*Me: No*

*ChatGPT: Is the object something that you would use for entertainment or leisure?*

*Me: Yes*

*ChatGPT: Is the object a musical instrument?*

*Me: No*

*ChatGPT: Is the object a type of game or puzzle?*

*Me: No*

*ChatGPT: Is the object a piece of technology such as a phone or computer?*

*Me: No*

*ChatGPT: Is the object a book or magazine?*

*Me: Yes*

*ChatGPT: Is the object a novel or a collection of short stories?*

*Me: Yes*

*ChatGPT: Is the object a specific book that is widely known and read?*

*Me: Yes*

*ChatGPT: Is the object "To Kill a Mockingbird" by Harper Lee?*

*Me: No*

*ChatGPT: I'm sorry, I'm running out of ideas. Can you give me a hint or tell me the answer?*

Seems like we hit a wall here with twenty questions, but ChatGPT is very close, so I decided to give a hint.

*Me: You are on the right track. It is by Walt Whitman*

*ChatGPT: Is the object "Leaves of Grass" by Walt Whitman?*

*Me: Yes! Congratulations!*

*ChatGPT: Thank you! I'm glad I was able to guess the object you were thinking of. It was fun playing "Twenty Questions" with you. Let me know if you want to play again sometime.*

---

I’ve been keeping an eye on how other people are using ChatGPT, and [prompt engineering](https://en.wikipedia.org/wiki/Prompt_engineering) is one of the more fascinating aspects around how people are communicating with the AI. Prompt engineering plays a key role in communicating with models like ChatGPT. Carefully crafting prompts can help maximize the quality of the reponse. However, it is important to keep in mind that, like any AI model, ChatGPT has its own set of limitations.

So I was curious when I read that “[ChatGPT can’t write sentences that end in a specific letter](https://www.reddit.com/r/ChatGPT/comments/101e454/chatgpt_cant_write_sentences_that_end_with_a/)”. Is this a real limitation of ChatGPT, or maybe this was just a poor prompt.

So let’s start with a very simple question to ChatGPT:

*Me: Can you write a sentence that ends with the letter "a"?*

*ChatGPT: The cat sat on the mat.*

*Me: That sentence does not end in the letter "a". Can you write a sentence that ends in the letter "a"?*

*ChatGPT: I can't think of anything right now, but the word "America" ends with letter "a".*

*Me: Great, write a sentence that ends in that word. That will then satisfy the original question.*

*ChatGPT: The land of the free, and the home of the brave, America.*

Okay, that does technically end in the letter a, but the sentence seems very strange.

*Me: That isn't a very coherent sentence. Can you write a sentence that ends in the letter "a"?*

*ChatGPT: I am sorry for the confusion, here is a sentence that ends with the letter "a" - "He saw the drama unfold on the stage, it was quite the spectacle, a.”*

Looks like we are going off the rails here. Let’s try a different approach:

*Me: Write a sentence that ends in a word that ends with the letter "a".*

*ChatGPT: The sun was setting over the horizon, painting the sky with shades of orange and red, a spectacle to behold and end the day with.*

I’m going to ask ChatGPT to tell me a prompt to feed back to itself. I’ve found this useful for resetting context when having long conversations. Or if ChatGPT gets into weird states like the above response.

*Me: Can you tell me how to write a prompt for you that would actually get you to write a sentence that ends in the letter "a".*

*ChatGPT: Sure, to get me to write a sentence that ends in the letter "a" you could provide a prompt like: "Write a sentence that ends with a word that ends with the letter 'a'" or "Can you write a sentence with a word ending in 'a' at the end of the sentence?" . This makes it clear that the sentence should end in a word ending with the letter 'a'.*

*Me: Can you write a sentence with a word ending in 'a' at the end of the sentence?*

*ChatGPT: The sky was clear and blue, not a cloud in sight, perfect for a day out at the parka.*

---

While ChatGPT is great at forming sentences and even code, it seems like it has no understanding and hasn’t been trained on letters, syllables, or the concept of sentences. I've seen others get ChatGPT to create poems, but it has no concept of why words would rhyme. It can give great answers to questions, but doesn’t understand how to count how many words are in its response.

One Redditor in the link above mentions that ChatGPT fails at ASCII art. I’ve tried getting the AI to print ASCII art before, and I’ll leave you with part of a conversation I’ve had with it. This appears to be the best ASCII art I could get it to print, even after having a long conversation where I provided different ASCII art examples:

*Me: Can you make ASCII art? Show me a picture of a cat.*

*ChatGPT: Sure! Here is a picture of a cat using ASCII art:*

```
 /\_/\
( o.o )
 >^<

```

*I hope you like it! Is there anything else I can help with?*

*Me: Can you make it more detailed*

*ChatGPT: Certainly! Here is a more detailed version of an ASCII art cat:*

```
 /\_/\
( o.o )
 >^<
 | |
 || ||
 \\ //
 // \\
 \\_//
 / \
 / \

```

With new language models coming out, it's important to recognize what the limitations
of the AI are. Poor responses can be a result of poorly written prompts, but there
are times, like with letters in words with ChatGPT, where the AI just doesn't have
the capability to understand the question.