Job Hunting Is Annoying. Build an AI Assistant to Automate the Application process.

What matters architecturally here is not just the AI output, but the workflow boundary around it. A job-application assistant like this sits between user-authored content, third-party model APIs, and a lightweight web UI. That makes prompt design, response shaping, and parsing conventions part of the application contract. If the model changes tone or output format, the downstream split logic can break, so productionizing this pattern usually means stronger schema enforcement, stricter section markers, or post-generation validation.

The bigger trade-off is convenience versus data exposure. Rรฉsumรฉs, bios, and job descriptions are personally identifiable and often sensitive career data, yet the app forwards them to external model providers. For teams adopting a similar pattern, secrets management, API key handling, and retention policies matter as much as the UI. Even a prototype benefits from clear boundaries around what is stored, what is logged, and what is sent to the model, especially when feedback capture or telemetry is added later.

There is also an integration lesson in the Google Sheets feedback loop. It is a pragmatic low-friction backend for iteration, but it couples product learning to a consumer spreadsheet service rather than a durable data pipeline. That is fine for early-stage experimentation, yet it introduces operational limits around access control, auditability, and long-term maintainability. If the tool grows, the feedback path may need to move toward a proper datastore, queue, or analytics layer.

For engineering teams, this is a good example of AI as workflow automation rather than standalone intelligence. The value comes from stitching together model inference, a simple interface, and a human review step. The most important design question is not whether the model can write a letter, but how reliably the system can turn unstructured inputs into usable, editable documents without creating extra risk or maintenance overhead.


Job hunting can be soul-sucking. Scouring job boards, tailoring resumes, crafting cover letters, and reaching out to recruiters โ€” itโ€™s a full-time job on its own, minus the pay. Itโ€™s daunting, boring, and to be honest, a bit of an emotional rollercoaster. I genuinely feel itโ€™s one of the most monotonous tasks ever. These days, whenever I face a boring task, my brain instantly goes: wait, why not let a language model do it for you? So, in an effort to answer that question and inject some efficiency into the job application process, I built a quick AI prototype: a Streamlit app powered by AI to ease the pain of job applications. This article is all about how to make job searching a little less painful and faster, and in general, learn how to build a quick prototype to help out with tasks AI can do for you.

Why This App?

Just applying for a ton of jobs with the same exact resume and not sending a cover letter doesnโ€™t really do much. But tailoring your resume for each application, writing a personalized cover letter, and sending a customized cold email to recruiters are strategies known to increase your chances significantly. But theyโ€™re also time-consuming. Thatโ€™s where this app comes in. It uses AI to tailor your resume based on the job description, generates a coherent and relevant cover letter, and outputs a personalized cold email ready to send to recruiters. This pretty much embodies what I believe to be a decent strategy for job applications: tailor the resume to the job description, write a cover letter, apply for the job, then find the email for the recruiter and send a personalized cold email. This is time-consuming, which is why we use AI to make the whole thing a little less painful and a lot faster.

What Do You Need?

To use the app, you just need a valid OpenAI or Anthropic API key with sufficient funds in your account. Then, youโ€™re all set to check out the app here and give it a spin by pasting your documents and letting the AI work its magic. โœจ To build the app, some Python know-how and comfort in connecting APIs are essential. A little familiarity with Streamlit will also go a long way.

What does this App do?

The core of the app is built around a simple idea: input your resume, the job description of the position you want to apply for, and a bit of personal bio, and let the AI do its thing. The output? Customized resume, cover letter, and cold email are ready for you to use for your application and send to the recruiter.

What tech are we using?

At its core, the app gives users the flexibility to choose between Anthropic and OpenAI as their chosen AI provider to generate the docs. This allows for a more tailored experience, as each provider has its own unique strengths (I personally prefer Anthropic these days). To create an intuitive interface, we leverage the simplicity of Streamlit, a Python library that makes it easy to turn scripts into shareable web apps. And since I am interested in improving the app based on user feedback, Iโ€™ve integrated a Google Sheets backend to collect and store user suggestions.

Breaking down the code

Letโ€™s dive into the app. We are going to go through the code piece by piece to make sure itโ€™s broken down and easy to follow. Weโ€™ll walk through each section, explaining its purpose and how it contributes to the overall functionality of the app. First things first: there are just two Python files: generator.py (responsible for generating the content) and app.py (our streamlit user interface)

Setting Up the Environment (`generator.py`)

import os
import logging
from dotenv import load_dotenv
import anthropic
import openai

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
The initial setup involves importing necessary libraries and configuring logging to help debug and track the appโ€™s performance. `load_dotenv` is used for loading environment variables securely, which includes our API keys for Anthropic and OpenAI, ensuring our app remains secure and functional.

Generating Documents

Hereโ€™s where the real fun begins. Weโ€™ve got a function thatโ€™s essentially the brain of the operation. You feed it your resume, job description, and a snippet about yourself, and it outputs all the tailored docs you need.
def generate_documents(resume, job_description, bio, api_key, ai_provider, formality_level, additional_info):
try:
if not api_key:
logging.error("API key not provided")
return None
if ai_provider == "Anthropic":
client = anthropic.Anthropic(api_key=api_key)
logging.info("Successfully created Anthropic client")
elif ai_provider == "OpenAI":
openai.api_key = api_key
logging.info("Successfully set OpenAI API key")
else:
logging.error("Invalid AI provider selected")
return None
This snippet checks for the API key and decides which AI provider to use based on what the userโ€™s picked in the frontend.

Crafting the AI Prompt

Next, we add a detailed prompt that guides the AI in generating a tailored resume, cover letter, and cold email. This part is essential for ensuring the outputs are relevant and personalized.
system_prompt = (
"You are an expert in early career professional resume crafting, cover letter writing, and cold email composition. "
"Your task is to generate a tailored resume, cover letter, and cold email for a job seeker based on the provided inputs."
)
prompt = (
"Given the following information for the candidate:\n\n"
"Resume:\n{resume}\n\n"
"Job Description:\n{job_description}\n\n"
"Bio/Brief Intro:\n{bio}\n\n"
"Formality Level for the cover letter: {formality_level}\n\n"
"Additional Information: {additional_info}\n\n"
"Please generate the following outputs:\n\n"
"===TAILORED RESUME===\n"
"Tailor the resume to highlight the candidate's relevant skills and experiences that match the job requirements. "
"Optimize the structure and formatting to make it more visually appealing and ATS-friendly, while maintaining the order of the sections and the exact length as much as possible.\n\n"
"===TAILORED COVER LETTER===\n"
"Craft a personalized cover letter that introduces the candidate, emphasizes their fit for the role, and encourages the recruiter to review the candidate's resume. "
"Include a brief introduction highlighting the candidate's interest and fit for the role, specific examples of how their skills and experiences align with the job requirements, "
"and a call-to-action encouraging the recruiter to consider the candidate for the role. Adjust the formality level based on the provided preference.\n\n"
"===CUSTOMIZED COLD EMAIL===\n"
"Generate a customized cold email that greets the recruiter, introduces the candidate, and invites the recruiter to consider the candidate for the role. "
"Adjust the formality level based on the provided preference.\n\n"
"Remember to keep the outputs concise, professional, and tailored to the specific job and candidate details provided. "
"THIS IS VERY IMPORTANT: Ensure that each output section is clearly delineated with the '===SECTION_TITLE===' format."
).format(resume=resume, job_description=job_description, bio=bio, formality_level=formality_level, additional_info=additional_info)
logging.info(f"Sending the following prompt to the AI: {prompt}")
if ai_provider == "Anthropic":
response = client.messages.create(
model="claude-3-haiku-20240307",
max_tokens=4000,
system=system_prompt,
temperature=0.5,
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": prompt
}
]
}
]
)
logging.info("Successfully generated the documents using Anthropic")
logging.info(f"AI Response: {response.content[0].text.strip()}")
ai_response = response.content[0].text.strip()
elif ai_provider == "OpenAI":
response = openai.chat.completions.create(
model="gpt-4-turbo-preview",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt},
],
temperature=0.5,
)
logging.info("Successfully generated the documents using OpenAI")
logging.info(f"AI Response: {response.choices[0].message.content.strip()}")
ai_response = response.choices[0].message.content.strip()
else:
logging.error("Invalid AI provider selected")
return None
The prompt is designed to extract the best possible output from the AI, guiding it through the task with specific instructions and inputs. It also helps structure the output in a way that makes it easy for us to extract each document later.

Handling the AI Response

Once we send the prompt to the chosen AI and receive the output, we need to parse it, splitting it into distinct sections for the resume, cover letter, and email. This parsing is important to then display it properly in the Streamlit UI.
# Split the AI response into the individual outputs
sections = ai_response.split("\n\n===")
outputs = {}
for section in sections:
if section.strip():
section_title = section.strip().split("\n")[0].strip("===")
section_content = "\n".join(section.strip().split("\n")[1:])
outputs[section_title] = section_content
logging.info(f"Outputs: {outputs}")
return outputs
except Exception as e:
logging.error(f"Error generating documents: {e}")
return None
This section demonstrates how we split the output, organizing it into the 3 documents we will then pass to the frontend.

Streamlit Frontend (`app.py`)

Now, moving to `app.py`, this is where we create a quick and intuitive interface for users to interact with our app. Streamlitโ€™s straightforward syntax lets us focus on functionality rather than boilerplate code.
import streamlit as st
from generator import generate_documents
import gspread
from google.oauth2.service_account import Credentials
from google.oauth2 import service_account
import toml

def main():
st.title(" JobBot: your AI Job Application Sidekick")
# User input for API key and provider
st.sidebar.title("API Settings")
ai_provider_toggle = st.sidebar.toggle("Select AI Provider", value=True, key="ai_provider_toggle")
if ai_provider_toggle:
ai_provider = "**Anthropic**"
ai_provider_emoji = ""
else:
ai_provider = "**OpenAI**"
ai_provider_emoji = ""
st.sidebar.write(f"You have selected {ai_provider} {ai_provider_emoji}")
api_key = st.sidebar.text_input("Enter your API key:", type="password")
if not api_key:
st.sidebar.error(" Please enter a valid API key to use the app.")
st.stop()
Here, we define our appโ€™s title and proceed to build a form where users can input their resume, job description, and personal bio. This user-friendly interface is the bridge between the user and our AI-powered document generator.

User Inputs and Document

We guide users through inputting their details and selecting preferences for their application documents. The magic happens when they hit the โ€œGenerate Docsโ€ button โ€” our app communicates with the AI, processes the inputs, and generates customized application documents.
# User inputs
st.subheader("Paste your resume here ")
resume = st.text_area("", height=200, placeholder="Your resume goes here...")
st.subheader("Paste the job description here ")
job_description = st.text_area("", height=200, placeholder="The job description goes here...")
st.subheader("Paste your bio/brief intro here โ€โ™‚๏ธ")
bio = st.text_area("", height=100, placeholder="Your bio or brief intro goes here. For example, you can add your LinkedIn summary or a short introduction about yourself.")
# Additional user inputs
st.sidebar.subheader("Additional Settings ")
formality_level = st.sidebar.select_slider("Formality Level for cover letter and email ", ["Super Casual", "Casual", "Neutral", "Formal", "Super Formal"], value="Neutral")
additional_info = st.sidebar.text_area("Additional Information ", height=100, placeholder="Anything else you want the AI to consider or focus on?")
# Define the output section titles
output_section_titles = {
"Tailored Resume": "TAILORED RESUME",
"Tailored Cover Letter": "TAILORED COVER LETTER",
"Customized Cold Email": "CUSTOMIZED COLD EMAIL"
}
if st.button("โœจGenerate Docs"):
# Show loader while generating documents
with st.spinner("AI is cooking up the docs to help with your application, just a few secs! โ€"):
# Generate outputs
outputs = generate_documents(resume, job_description, bio, api_key, ai_provider.replace("**", ""), formality_level, additional_info)
if outputs:
for section_title, section_key in output_section_titles.items():
if section_key in outputs and outputs[section_key].strip():
st.subheader(section_title)
st.code(outputs[section_key], language="text")
# How to use section in the sidebar
st.sidebar.subheader("How to Use ")
with st.sidebar.expander("Click here to see a quick guide!"):
st.markdown("""
- Copy and paste your resume
- Copy and paste the job description you're applying for
- โ€โ™‚๏ธ Provide a brief bio/intro about yourself
- Pick the formality level for the cover letter and email (default works well for most cases)
- Add any additional information you want the AI to consider (optional)
- Click the "Generate Documents" button and let the magic happen!โœจ
""")
This section of the code captures user inputs and triggers the document generation process, this is the appโ€™s core functionality.

Gathering user feedback (Google Sheets integration)

If you are interested in implementing in your app, this is how we gather feedback and store it in a Google Sheet. In addition to the core functionality of the app, I included a user feedback form in the sidebar. This allows users to share their thoughts, suggestions, and any features theyโ€™d find useful. The feedback is then stored in a Google Sheet, this way we can improve the app based on user input. The feedback form is built using Streamlitโ€™s form functionality. Users can simply enter their thoughts in the text area and click the โ€œSubmit Feedbackโ€ button. Behind the scenes, the app sets up the Google Sheets API using the TOML secrets provided in the Streamlit environment. Once the feedback is submitted, the app appends the userโ€™s input to a dedicated worksheet in the Google Sheet, making it easy to review and keep the app evolving based on userโ€™s inputs. Hereโ€™s the code:
# Feedback form in the sidebar
with st.sidebar:
st.subheader("Got Feedback or features you'd find useful? ")
# Start of the form
with st.form(key='feedback_form'):
feedback = st.text_area("Share your thoughts with me here:")
submit_feedback = st.form_submit_button(label='Submit Feedback ')
if submit_feedback:
# Set up the Google Sheets API using TOML secrets
try:
secrets = {
"type": st.secrets["type"],
"project_id": st.secrets["project_id"],
"private_key_id": st.secrets["private_key_id"],
"private_key": st.secrets["private_key"],
"client_email": st.secrets["client_email"],
"client_id": st.secrets["client_id"],
"auth_uri": st.secrets["auth_uri"],
"token_uri": st.secrets["token_uri"],
"auth_provider_x509_cert_url": st.secrets["auth_provider_x509_cert_url"],
"client_x509_cert_url": st.secrets["client_x509_cert_url"],
"universe_domain": st.secrets["universe_domain"]
}
creds = service_account.Credentials.from_service_account_info(
secrets,
scopes=['https://spreadsheets.google.com/feeds', 'https://www.googleapis.com/auth/spreadsheets', 'https://www.googleapis.com/auth/drive']
)
client = gspread.authorize(creds)
# Open the Google Sheet and append the feedback
sh = client.open('prototype_feedback').worksheet('Feedback')
sh.append_row([feedback])
st.sidebar.success("Thanks for your feedback! ")
except Exception as e:
st.sidebar.error(f"Error: {e}")
This is what our user interface looks like: Image from the author โ€” Made with โค๏ธ and Python.

Wrapping up and Trying It Out

Thatโ€™s all for this article! Dive into the code to build your own version by visiting the GitHub repo. You can also give the app a try here. Please remember to make sure you have a valid OpenAI or Anthropic API key! Excited to hear your feedback or any cool ideas you might have for further enhancements. This is just the starting point, I would love to make the job-hunting process as automated and painless as possible. If you found this article useful, consider expressing your appreciation with 50 claps โ€” your support means a ton. Thanks for following along, and happy coding! ๐Ÿ™‚ All images are by me, the author, unless otherwise noted. Apart from being a user, I have no affiliation with OpenAI, Streamlit, Anthropic or any other organisation.
Original Post

Enjoyed this article? Sign up for our newsletter to receive regular insights and stay connected.