Not solely the Mona Lisa and the Vitruvian Man but in addition the Curriculum Vitae (CV), are cultural artifacts by Leonardo Da Vinci’s hand that resonate and reproduce within the current time. The CV shouldn’t be the unique method to current oneself to the job market. But the CV persists regardless of the various improvements in info and graphics expertise since Leonardo enumerated on paper his expertise and talents to the Duke of Milan.
In high-level phrases, the creation of a CV:
- summarizes previous accomplishments and experiences of an individual in a doc kind,
- in a fashion related to a particular viewers, who in a short while assesses the particular person’s relative and absolute utility to some finish,
- the place the model and format of the doc kind are chosen to be conducive to a beneficial evaluation by stated viewers.
These are semantic operations in service of an goal underneath vaguely said constraints.
Giant language fashions (LLMs) are the premier means to execute semantic operations with computer systems, particularly if the operations are ambiguous in the best way human communication typically is. The commonest method to date to work together with LLMs is a chat app — ChatGPT, Claude, Le Chat and many others. We, the human customers of stated chat apps, outline considerably loosely the semantic operations by the use of our chat messages.
Sure purposes, nevertheless, are higher served by a special interface and a special method to create semantic operations. Chat shouldn’t be the be-all and end-all of LLMs.
I’ll use the APIs for the LLM models of Anthropic (particularly Sonnet and Haiku) to create a primary utility for CV meeting. It depends on a workflow of brokers working in live performance (an agentic workflow), every agent performing some semantic operation within the chain of actions it takes to go from a blob of private knowledge and historical past to a structured CV doc worthy of its august progenitor…
It is a tutorial on constructing a small but full LLM-powered non-chat utility. In what follows I describe each the code, my causes for a specific design, and the place within the larger image each bit of Python code matches.
The CV creation app is a helpful illustration of AIs engaged on the final job of structured style-content technology.
Earlier than Code & How — Present What & Wow
Think about a set of private knowledge and prolonged profession descriptions, principally textual content, organized into a number of information the place info is scattered. In that assortment is the uncooked materials of a CV. Solely it could take effort to separate the related from the irrelevant, distill and refine it, and provides it a great and nice kind.
Subsequent think about working a script make_cv and pointing it to a job advert, a CV template, an individual and some specification parameters:
make_cv --job-ad-company "epic decision index"
--job-ad-title "luxurious retail lighting specialist"
--cv-template two_columns_abt_0
--person-name "gregor samsa"
--output-file ../generated_output/cv_nice_two_columns.html
--n-words-employment 50 --n-skills 8 --n-words-about-me 40
Then wait a number of seconds whereas the info is shuffled, remodeled and rendered, after which the script outputs a neatly styled and populated one-pager two-column CV.
Good! Minimal format and magnificence in inexperienced hues, good distinction between textual content and background, not simply bland default fonts, and the content material consists of temporary and to-the-point descriptions.
However wait… are these paperwork not speculated to make us stand out?
Once more with assistance from the Anthropic LLMs, a special template is created (key phrases: wild and wacky world of early Nineties internet design), and the identical content material is given a brand new wonderful kind:
If you happen to ignore the flashy animations and peculiar color selections, you’ll discover that the content material and format are virtually similar to the earlier CV. This isn’t by probability. The agentic workflow’s generative duties deal individually with content material, kind, and magnificence, not resorting to an all-in-one answer. The workflow course of quite mirrors the modular construction of the usual CV.
That’s, the generative means of the agentic workflow is made to function inside significant constraints. That may improve the sensible utility of generative AI purposes — design, in spite of everything, has been stated to depend largely on constraints. For instance, branding, model guides, and knowledge hierarchy are helpful, principled constraints we should always need within the non-chat outputs of the generative AI — be they CVs, reviews, UX, product packaging and many others.
The agentic workflow that accomplishes all that’s illustrated under.
If you happen to want to skip previous the descriptions of code and software program design, Gregor Samsa is your lodestar. After I return to discussing purposes and outputs, I’ll accomplish that for artificial knowledge for the fictional character Gregor Samsa, so keyword-search your means ahead.
The entire code is obtainable in this GitHub repo, free and with none ensures.
Job Advert Pre-Processing, DAO and Immediate Meeting
It’s typically stated that one ought to tailor a CV’s content material to the job advert. Since job adverts are steadily verbose, typically containing authorized boilerplate and call info, I want to extract and summarize solely the related options and use that textual content in subsequent duties.
To have shared interfaces when retrieving knowledge, I make a primary data-access object (DAO), which defines a standard interface to the info, which within the tutorial instance is saved in textual content and JSON information regionally (saved in registry_job_ads), however typically may be another job advert database or API.
To summarize or summary textual content is a semantic operation LLMs are well-suited for. To that finish,
- an instruction immediate is required to make the LLM course of the textual content appropriately for the duty;
- and the LLM mannequin from Anthropic must be chosen together with its parameters (e.g. temperature);
- and the instructed LLM is invoked through a third-party API with its particular necessities on syntax, error checking and many others.
To maintain these three distinct issues separate, I introduce some abstraction.
The category diagram under illustrates key strategies and relationships of the agent that extract key qualities of the job advert.
In code, that appears like this:
The configuration file agent_model_extractor_confs is a JSON file that partially appears to be like like this:
Extra configurations are added to this file as additional brokers are applied.
The immediate is what focuses the final LLM onto a particular functionality. I take advantage of Jinja templates to assemble the immediate. It is a flexible and established method to create text files with programmatic content. For the pretty easy job advert extractor agent, the logic is easy — learn textual content from a file and return it — however once I get to the extra superior brokers, Jinja templating will show extra useful.
And the immediate template for agent_type='JobAdQualityExtractor is:
Your job is to research a job advert and from it extract,
on the one hand, the qualities and attributes that the
firm is in search of in a candidate, and on the opposite
hand, the qualities and aspirations the corporate
communicates about itself.Any boilerplate textual content or contact info needs to be
ignored. And the place potential, scale back the general quantity
of textual content. We're in search of the essence of the job advert.
Invoking the Agent, With out Instruments
A mannequin title (e.g. claude-3–5-sonnet-20240620), a immediate and an Anthropic shopper are the least we have to ship a request to the Anthropic APIs to execute an LLM. The job advert high quality extractor agent has all of it. It could actually due to this fact instantiate and execute the “naked metallic” agent sort.
With none reminiscence of prior use or another performance, the naked metallic agent invokes the LLM as soon as. Its scope of concern is how Anthropic codecs its inputs and outputs.
I create an summary base class as nicely, Agent. It isn’t strictly required and for a job as primary as CV creation of restricted use. Nevertheless, if we had been to maintain constructing on this basis to take care of extra complicated and numerous duties, abstract base classes are good practice.
The send_request_to_anthropic_message_creation is a simple wrapper around the call to the Anthropic API.
That is all that’s wanted to acquire the job advert abstract. Briefly, the steps are:
- Instantiate a job advert high quality extractor agent, which entails gathering the related immediate and Anthropic mannequin parameters.
- Invoke the job advert knowledge entry object with an organization title and place to get the entire job advert textual content.
- Apply the extraction on the entire job advert textual content, which entails a one-time request to the APIs of the Anthropic LLMs; a textual content string is returned with the generated abstract.
By way of code within the make_cv script, these steps learn:
# Step 0: Get Anthropic shopper
anthropic_client = get_anthropic_client(api_key_env)# Step 1: Extract key qualities and attributes from job advert
ad_qualities = JobAdQualityExtractor(
shopper=anthropic_client,
).extract_qualities(
textual content=JobAdsDAO().get(job_ad_company, job_ad_title),
)
The highest a part of the info move diagram has thus been described.
How To Construct Brokers That Use Instruments
All different varieties of brokers within the agentic workflow use instruments. Most LLMs these days are geared up with this convenient capability. Since I described the naked metallic agent above, I’ll describe the tool-using agent subsequent, since it’s the basis for a lot to comply with.
LLMs generate string knowledge by a sequence-to-sequence map. In chat purposes in addition to within the job advert high quality extractor, the string knowledge is (principally) textual content.
However the string knowledge can be an array of perform arguments. For instance, if I’ve an executable perform, add, that provides two integer variables, a and b, and returns their sum, then the string knowledge to run add might be:
{
"title": "add",
"enter": {
"a": "2",
"b": "2"
}
}
So if the LLM outputs this string of perform arguments, it will probably in code result in the perform name add(a=2, b=2).
The query is: how ought to the LLM be instructed such that it is aware of when and the right way to generate string knowledge of this sort and particular syntax?
Alongside the AgentBareMetal agent, I outline one other agent sort, which additionally inherits the Agent base class:
This differs from the naked metallic agent in two regards:
self.instrumentsis a listing created throughout instantiation.tool_returnis created throughout execution by invoking a perform obtained from a registry,registry_tool_name_2_func.
The previous object incorporates the info instructing the Anthropic LLMs on the format of the string knowledge it will probably generate as enter arguments to completely different instruments. The latter object comes about by the execution of the software, given the LLM-generated string knowledge.
The tools_cv_data file incorporates a JSON string formatted to outline a perform interface (however not the perform itself). The string has to adapt to a very specific schema for the Anthropic LLM to know it. A snippet of this JSON string is:
From the specification above we are able to inform that if, for instance, the initialization of AgentToolInvokeReturn consists of the string biography within the instruments argument, then the Anthropic LLM might be instructed that it will probably generate a perform argument string to a perform referred to as create_biography. What sort of knowledge to incorporate in every argument is left to the LLM to determine from the outline fields within the JSON string. These descriptions are due to this fact mini-prompts, which information the LLM in its sense-making.
The perform that’s related to this specification I implement by the next two definitions.
Briefly, the software title create_biography is related to the category builder perform Biography.construct, which creates and returns an occasion of the info class Biography.
Be aware that the attributes of the info class are completely mirrored within the JSON string that’s added to the self.instruments variable of the agent. That means that the strings returned from the Anthropic LLM will match completely into the category builder perform for the info class.
To place all of it collectively, take a more in-depth have a look at the internal loop of the run methodology of AgentToolInvokeRetur proven once more under:
for response_message in response.content material:
assert isinstance(response_message, ToolUseBlock)tool_name = response_message.title
func_kwargs = response_message.enter
tool_id = response_message.id
software = registry_tool_name_2_func.get(tool_name)
attempt:
tool_return = software(**func_kwargs)
besides Exception:
...
The steps are:
- The response from the Anthropic LLM is checked to be a string of perform arguments, not abnormal textual content.
- The title of the software (e.g.
create_biography), the string of perform arguments and a novel software use id are gathered. - The executable software is retrieved from the registry (e.g.
Biography.construct). - The perform is executed with the string perform arguments (checking for errors)
As soon as we have now the output from the software, we should always resolve what to do with it. Some purposes combine the software outputs into the messages and execute one other request to the LLM API. Nevertheless, within the present utility, I construct brokers that generate knowledge objects, particularly subclasses of CVData. Therefore, I design the agent to invoke the software, after which merely return its output — therefore the category title AgentToolInvokeReturn.
It’s on this basis I construct brokers which create the constrained knowledge buildings I wish to be a part of the CV.
Structured CV Information Extractor Brokers
The category diagram for the agent that generates structured biography knowledge is proven under. It has a lot in widespread with the earlier class diagram for the agent that extracted the qualities from job adverts.
In code:
Two distinctions to the earlier agent JobAdQualityExtractor:
- The software names are retrieved as a perform of the category attribute
cv_data(line 47 within the snippet above). So when the agent with instruments is instantiated, the sequence of software names is given by a registry that associates a kind of CV knowledge (e.g.Biography) with the important thing used within thetools_cv_dataJSON string described above, e.g.biography. - The immediate for the agent is rendered with variables (strains 48–52). Recall the usage of Jinja templates above. This allows the injection of the related qualities of the job advert and a goal variety of phrases for use within the “about me” part. The particular template for the biography agent is:
Meaning as it’s instantiated, the agent is made conscious of the job advert it ought to tailor its textual content output to.
So when it receives the uncooked textual content knowledge, it performs the instruction and returns an occasion of the info class Biography. With similar causes and related software program design, I generate further extractor brokers and CV knowledge lessons and instruments definitions:
class EducationCVDataExtractor(CVDataExtractor):
cv_data = Educations
def __init__(self):
# <truncated>class EmploymentCVDataExtractor(CVDataExtractor):
cv_data = Employments
def __init__(self):
# <truncated>
class SkillsCVDataExtractor(CVDataExtractor):
cv_data = Expertise
def __init__(self):
# <truncated>
We are able to now go up a stage within the abstractions. With extractor brokers in place, they need to be joined to the uncooked knowledge from which to extract, summarize, rewrite and distill the CV knowledge content material.
Orchestration of Information Retrieval and Extraction
The a part of the info diagram to elucidate subsequent is the highlighted half.
In precept, we can provide the extractor brokers entry to all potential textual content we have now for the particular person we’re making the CV for. However which means the agent has to course of an excessive amount of knowledge irrelevant to the particular part it’s targeted on, e.g. formal academic particulars are hardly present in private stream-of-consciousness running a blog.
That is the place essential questions of retrieval and search often enter the design issues of LLM-powered purposes.
Will we attempt to discover the related uncooked knowledge to use our brokers to, or can we throw all we have now into the big context window and let the LLM type out the retrieval query? Many have had their say on the matter. It’s a worthwhile debate as a result of there’s a variety of reality within the under assertion:
For my utility, I’ll maintain it easy — retrieval and search are saved for one more day.
Due to this fact, I’ll work with semi-structured uncooked knowledge. Whereas we have now a normal understanding of the content material of the respective paperwork, internally they consist principally of unstructured textual content. This state of affairs is widespread in lots of real-world circumstances the place helpful info may be extracted from the metadata on a file system or knowledge lake.
The primary piece within the retrieval puzzle is the info entry object (DAO) for the template desk of contents. At its core, that could be a JSON string like this:
It associates the title of a CV template, e.g. single_column_0, with a listing of required knowledge sections — the CVData knowledge lessons described in an earlier part.
Subsequent, I encode which uncooked knowledge entry object ought to go together with which CV knowledge part. In my instance, I’ve a modest assortment of uncooked knowledge sources, every accessible by a DAO, e.g. PersonsEmploymentDAO.
_map_extractor_daos: Dict[str, Tuple[Type[DAO]]] = {
f'{EducationCVDataExtractor.cv_data.__name__}': (PersonsEducationDAO,),
f'{EmploymentCVDataExtractor.cv_data.__name__}': (PersonsEmploymentDAO,),
f'{BiographyCVDataExtractor.cv_data.__name__}': (PersonsEducationDAO, PersonsEmploymentDAO, PersonsMusingsDAO),
f'{SkillsCVDataExtractor.cv_data.__name__}': (PersonsEducationDAO, PersonsEmploymentDAO, PersonsSkillsDAO),
}
"""Map CV knowledge varieties to DAOs that present uncooked knowledge for the CV knowledge extractor brokersThis permits for a pre-filtering of uncooked knowledge which might be handed to the extractors. For instance,
if the extractor is tailor-made to extract training knowledge, then solely the training DAO is used.
That is strictly not wanted for the reason that Extractor LLM ought to have the ability to do the filtering itself,
although at a better token value.
"""
Be aware on this code that the Biography and Expertise CV knowledge are created from a number of uncooked knowledge sources. These associations are simply modified if further uncooked knowledge sources change into accessible — append the brand new DAO to the tuple — or made configurable at runtime.
It’s then a matter of matching the uncooked knowledge and the CV knowledge extractor brokers for every required CV part. That’s the knowledge move that the orchestrator implements. The picture under is a zoomed-in knowledge move diagram for the CVDataExtractionOrchestrator execution.
In code, the orchestrator is as follows:
And placing all of it collectively within the script make_cv we have now:
# Step 2: Verify the info sections required by the CV template and accumulate the info
cv_data_orchestrator = CVDataExtractionOrchestrator(
shopper=anthropic_client,
relevant_qualities=ad_qualities,
n_words_employment=n_words_employment,
n_words_education=n_words_education,
n_skills=n_skills,
n_words_about_me=n_words_about_me,
)
template_required_cv_data = FormTemplatesToCDAO().get(cv_template, 'required_cv_data_types')
cv_data = {}
for required_cv_data in template_required_cv_data:
cv_data.replace(cv_data_orchestrator.run(
cv_data_type=required_cv_data,
data_key=person_name
))
It’s inside the orchestrator due to this fact that the calls to the Anthropic LLMs happen. Every name is finished with a programmatically created instruction immediate, usually together with the job advert abstract, some parameters of how wordy the CV sections needs to be, plus the uncooked knowledge, keyed on the title of the particular person.
The loop yields a set of structured CV knowledge class situations as soon as all of the brokers that use instruments have concluded their duties.
Interlude: None, <UNKNOWN>, “lacking”
The Anthropic LLMs are remarkably good at matching their generated content material to the output schema required to construct the info lessons. For instance, I do not sporadically get a cellphone quantity within the electronic mail discipline, nor are invalid keys dreamt up, which might break the construct capabilities of the info lessons.
However once I ran checks, I encountered an imperfection.
Look once more at how the Biography CV knowledge is outlined:
If for instance, the LLM doesn’t discover a GitHub URL in an individual’s uncooked knowledge, then it’s permissible to return None for that discipline, since that attribute within the knowledge class is optionally available. That’s how I need it to be because it makes the rendering of the ultimate CV less complicated (see under).
However the LLMs usually return a string worth as a substitute, usually '<UNKNOWN>'. To a human observer, there isn’t a ambiguity about what this implies. It isn’t a hallucination in that it’s a fabrication that appears actual but is with out foundation within the uncooked knowledge.
Nevertheless, it is a matter for a rendering algorithm that makes use of easy conditional logic, reminiscent of the next in a Jinja template:
<div class="contact-info">
{{ biography.electronic mail }}
{% if biography.linkedin_url %} — <a href="{{ biography.linkedin_url }}">LinkedIn</a>{% endif %}
{% if biography.cellphone %} — {{ biography.cellphone }}{% endif %}
{% if biography.github_url %} — <a href="{{ biography.github_url }}">GitHub</a>{% endif %}
{% if biography.blog_url %} — <a href="{{ biography.blog_url }}">Weblog</a>{% endif %}
</div>
An issue that’s semantically apparent to a human, however syntactically messy, is ideal for LLMs to take care of. Inconsistent labelling within the pre-LLM days induced many complications and prolonged lists of inventive string-matching instructions (anybody who has accomplished knowledge migrations of databases with many free-text fields can attest to that).
So to take care of the imperfection, I create one other agent that operates on the output of one of many different CV knowledge extractor brokers.
This agent makes use of objects described in earlier sections. The distinction is that it takes a set of CV knowledge lessons as enter, and is instructed to empty any discipline “the place the worth is one way or the other labelled as unknown, undefined, not discovered or related” (a part of the full prompt).
A joint agent is created. It first executes the creation of biography CV knowledge, as described earlier. Second, it executes the clear undefined agent on the output of the previous agent to repair points with any <UNKNOWN> strings.
This agent solves the issue, and due to this fact I take advantage of it within the orchestration.
May this imperfection be solved with a special instruction immediate? Or would a easy string-matching repair be enough? Possibly.
Nevertheless, I take advantage of the best and most cost-effective LLM of Anthropic (haiku), and due to the modular design of the brokers, it’s a simple repair to implement and append to the info pipeline. The power to assemble joint brokers that comprise a number of different brokers is without doubt one of the design patterns superior agentic workflows use.
Render With CV Information Objects Assortment
The ultimate step within the workflow is relatively easy due to that we spent the trouble to create structured and well-defined knowledge objects. The contents of stated objects are particularly positioned inside a Jinja HTML template by syntax matching.
For instance, if biography is an occasion of the Biography CV knowledge class and env a Jinja setting, then the next code
template = env.get_template('test_template.html')
template.render(biography=biography)
would for test_template.html like
<physique>
<h1>{{ biography.title }}</h1>
<div class="contact-info">
{{ biography.electronic mail }}
</div>
</physique>
match the title and electronic mail attributes of the Biography knowledge class and return one thing like:
<physique>
<h1>My N. Ame</h1>
<div class="contact-info">
my.n.ame@compuserve.com
</div>
</physique>
The perform populate_html takes all of the generated CV Information objects and returns an HTML file utilizing Jinja performance.
Within the script make_cv the third and closing step is due to this fact:
# Step 3: Render the CV with knowledge and template and save output
html = populate_html(
template_name=cv_template,
cv_data=listing(cv_data.values()),
)
with open(output_file, 'w') as f:
f.write(html)
This completes the agentic workflow. The uncooked knowledge has been distilled, the content material put inside structured knowledge objects that mirror the knowledge design of normal CVs, and the content material rendered in an HTML template that encodes the model selections.
What In regards to the CV Templates — Learn how to Make Them?
The CV templates are Jinja templates of HTML information. Any software that may create and edit HTML information can due to this fact be used to create a template. So long as the variable naming conforms to the names of the CV knowledge lessons, it will likely be suitable with the workflow.
So for instance, the next a part of a Jinja template would retrieve knowledge attributes from an occasion of the Employments CV data class, and create a listing of employments with descriptions (generated by the LLMs) and knowledge on period (if accessible):
<h2>Employment Historical past</h2>
{% for employment in employments.employment_entries %}
<div class="entry">
<div class="entry-title">
{{ employment.title }} at {{ employment.firm }} ({{ employment.start_year }}{% if employment.end_year %} - {{ employment.end_year }}{% endif %}):
</div>
{% if employment.description %}
<div class="entry-description">
{{ employment.description }}
</div>
{% endif %}
</div>
{% endfor %}
I do know little or no about front-end growth — even HTML and CSS are uncommon within the code I’ve written through the years.
I made a decision due to this fact to make use of LLMs to create the CV templates. In any case, this can be a job during which I search to map an look and design wise and intuitive to a human observer to a string of particular HTML/Jinja syntax — a type of job LLMs have confirmed fairly apt at.
I selected to not combine this with the agentic workflow however appended it within the nook of the info move diagram as a helpful appendix to the appliance.
I used Claude, the chat interface to Anthropic’s Sonnet LLM. I offered Claude with two issues: a picture and a immediate.
The picture is a crude define of a single-column CV I prepare dinner up shortly utilizing a phrase processor after which screen-dump.
The prompt I give is fairly lengthy. It consists of three elements.
First, a press release of what I want to accomplish and what info I’ll present Claude as Claude executes the duty.
A part of the immediate of this part reads:
I want to create a Jinja2 template for a static HTML web page. The HTML web page goes to current a CV for an individual. The template is supposed to be rendered with Python with Python knowledge buildings as enter.
Second, a verbal description of the format. In essence, an outline of the picture above, high to backside, with remarks about relative font sizes, the order of the sections and many others.
Third, an outline of the info buildings that I’ll use to render the Jinja template. Partly, this immediate reads as proven within the picture under:
The immediate continues itemizing all of the CV knowledge lessons.
To a human interpreter, who’s educated in Jinja templating, HTML and Python knowledge lessons, this info is enough to allow matching the semantic description of the place to position the e-mail within the format to the syntax {{ biography.electronic mail }} within the HTML Jinja template, and the outline of the place to position the LinkedIn profile URL (if accessible) within the format to the syntax {% if biography.linkedin_url %} <a href=”{{ biography.linkedin_url }}”>LinkedIn</a>{% endif } and so forth.
Claude executes the duty completely — no want for me to manually edit the template.
I ran the agent workflow with the single-column template and artificial knowledge for the persona Gregor Samsa (see extra about him later).
make_cv --job-ad-company "epic decision index"
--job-ad-title "luxurious retail lighting specialist"
--cv-template single_column_0
--person-name "gregor samsa"
--output-file ../generated_output/cv_single_column_0.html
--n-words-employment 50 --n-skills 8
The output doc:
An honest CV. However I wished to create variations and see what Claude and I might prepare dinner up.
So I created one other immediate and display dump. This time for a two-column CV. The crude define I drew up:
I reused the immediate for the one column, solely altering the second half the place I in phrases describe the format.
It labored completely once more.
The styling, although, was a bit too bland for my style. In order a follow-up immediate to Claude, I wrote:
Like it! Are you able to redo the earlier job however with one modification: add some spark and color to it. Arial font, black and white is all a bit boring. I like a little bit of inexperienced and nicer trying fonts. Wow me! After all, it needs to be professional-looking nonetheless.
Had Claude responded with an irritated remark that I have to be a bit extra particular, I might have empathized (in some sense of that phrase). Slightly, Claude’s generative juices flowed and a template was created that when rendered seemed like this:
Good!
Notably, the elemental format within the crude define is preserved on this model: the position of sections, the relative width of the 2 columns, and the dearth of descriptions within the training entries and many others. Solely the model modified and was in step with the obscure specs given. Claude’s generative capacities stuffed within the gaps fairly nicely in my judgment.
I subsequent explored if Claude might maintain the template format and content material specs clear and constant even once I dialled up the styling to eleven. So I wrote subsequent to Claude:
Wonderful. However now I need you to go all out! We’re speaking early Nineties internet web page aesthetic, blinking stuff, comedian sans within the oddest locations, bizarre and loopy color contrasts. Full pace forward, Claude, have some enjoyable.
The end result was wonderful.
Who is that this Gregor Samsa, what a free-thinker and never a hint of hysteria — rent the man!
Even with this excessive styling, the desired format is generally preserved, and the textual content content material as nicely. With an in depth sufficient immediate, Claude can seemingly create practical and properly styled templates that may be a part of the agentic workflow.
What In regards to the Textual content Output?
Eye-catching model and helpful format apart, a CV should include abbreviated textual content that succinctly and honestly exhibits the match between particular person and place.
To discover this I created artificial knowledge for an individual Gregor Samsa — educated in Central Europe, working in lighting gross sales, with a normal curiosity in entomology. I generated uncooked knowledge on Gregor’s previous and current, some from my creativeness, and a few from LLMs. The small print aren’t essential. The important thing level is that the textual content is simply too muddled and unwieldy to be copy-pasted right into a CV. The info must be discovered (e.g. the e-mail tackle seems inside one among Gregor’s normal musings), summarized (e.g. the outline of Gregor’s PhD work could be very detailed), distilled and tailor-made to the related place (e.g. which expertise are value bringing to the fore), and all lowered to 1 or two pleasant sentences in an about me part.
The textual content outputs had been very nicely made. I had Anthropic’s most superior and eloquent mannequin, Sonnet, write the About Me sections. The tone rang true.
In my checks, I discovered no outright hallucinations. Nevertheless, the LLMs had taken sure liberties within the Expertise part.
Gregor is described within the uncooked knowledge as working and finding out in Prague and Vienna principally with some on-line lessons from English-language educators. In a single generated CV, language expertise in Czech, German and English had been listed regardless of that the uncooked knowledge doesn’t explicitly declare such information. The LLM had made an inexpensive inference of expertise. Nonetheless, these weren’t expertise abstracted from the uncooked knowledge alone.