Sharing intro cards

Those who know me know that I am fairly introverted. But, I am also someone who strongly values community, and thinks there are huge benefits to be had by building or connecting to one.

A big part of building or integrating into communities is getting to know the people in them. Some people have a natural talent for this. Others have built that skill through many years of deliberate practice. There are also some people who use software to manage and track these relationships “personal CRM”-style (e.g., Monica, or really detailed notes in Google Contacts).

I am currently none of these people.

But, I would like to build the skill.

One reason knowing people is valuable is that it helps facilitate connection. “Oh, I know X is in that industry, let me connect you.” “The Y family has kids that line up with your kids age and go to Z Junior High, too.” “Oh A used to live right around there, let’s ask them for advice.” These types of serendipitous connections can build strong bonds and strengthen a community, but you can only make them if you know enough.

To that end, I think “intro cards” are an interesting idea. Imagine that when you moved in somewhere, or went to a new neighborhood meeting or church event, or met with the other parents for your kid’s soccer team, you could get a small physical card of pertinent information about these new people you met.

In big social settings like that, where you’re meeting a lot of new people, it’s very easy (for me, anyway) to have forgotten the names of the people I just talked to. Now, instead imagine that throughout the event, you were exchanging intro cards, something like the following.

An example intro card
An example intro card, 3“×5“ sized.

During the event, you could focus completely on the current conversations, knowing you already have some notes provided to you to recall the previous ones.

Is the concept so wild? In Japan, there is a whole interesting culture around exchanging business cards. In the US, we rarely do so. A small Japanese town recently went even further, making a whole trading card game for the middle-aged members of their town, connecting the youth to older generations in a heartwarming way.

Naturally, these intro cards might include personal information you probably wouldn’t put on the Internet, but might want to provide to people depending on the context. So, of course, you should tune the content to the purpose. You should also feel things out first, before you just go handing these to everyone. For example, in the context of introducing yourself to neighbors, maybe it is something like Bart’s above. If it’s meeting coworkers, maybe it highlights parts of the system you’re familiar with, or your favorite software or languages. If it’s a hobby group, maybe it highlights more about your specific niche interests.

I’ve started trying this idea out in a few scenarios, to positive reception. To make it easy, I just print these on 3“×5“ index cards at home rather than deal with producing actual cards. An example Typst document for it is included below.


Source Code: Example Intro Card in Typst
#set text(font: "Berkeley Mono")
#set text(9pt)
#set par(leading: 0.35em)
#set page(
  width: 3in,
  height: 5in,
  margin: 0.25in,
  // background: rect(width: 100%, height: 100%, stroke: 1pt + black),
)

// Placed here because these are reused to make links
#let telephone_number = "xxx-xxx-xxxx"
#let email_address = "[email protected]"
#let website = "www.example.com"

#grid(
  columns: 100%,
  rows: (1%, 1%, 40%, 2%, 2%, 1fr),
  gutter: 1.0mm,
  grid.cell(
    text(size: 11pt, weight: "bold", "Bart Simpson"),
    align: (left + horizon),
  ),
  [],
  grid.cell(
    block(clip: true, radius: 3mm, image("bart.png")),
    align: (center + horizon),
  ),
  [],
  grid.hline(stroke: (paint: gray, thickness: 0.75pt, cap: "round"), y: 4),
  [],
  grid(
    columns: (20%, 1fr),
    column-gutter: 2mm,
    row-gutter: 2.20mm,
    // stroke: 1pt + silver,
    grid.cell([*age*], align: right), grid.cell(
      [Born in XXXX],
      align: left,
    ),
    grid.cell([*family*], align: right), grid.cell(
      [Spouse: Susan \
        Children: Johnny (M, XXXX)],
      align: left,
    ),
    grid.cell([*rel-to*], align: right), grid.cell(
      [Marge (mom), Homer (dad), Lisa (sis), Maggie (sis)],
      align: left,
    ),
    grid.cell([*from*], align: right), grid.cell(
      [New York, NY (--XXXX) \ Chicago, IL (--XXXX)],
      align: left,
    ),
    grid.cell([*job*], align: right), grid.cell(
      [Manager at #link("https://www.example.com")[Example]],
      align: left,
    ),
    grid.cell([*edu*], align: right), grid.cell(
      [NYU (BS in PR, 'XX)],
      align: left,
    ),
    grid.cell([*email*], align: right), grid.cell(
      link("mailto:" + email_address, email_address),
      align: left,
    ),
    grid.cell([*phone*], align: right), grid.cell(
      link("tel:" + telephone_number, telephone_number),
      align: left,
    ),
    grid.cell([*website*], align: right), grid.cell(
      link("https://" + website, website),
      align: left,
    ),
    [], grid.cell(
      text(size: 5pt, style: "italic")[v25.03], // calver
      align: right + top,
    ),
  )
)

Posts from blogs I follow

The Past, Present, and Future of Digital Storytelling with Ramy Katrib

Ramy Katrib has been at the forefront of digital storytelling for over 25 years, with his post-production company, DigitalFilm Tree, earning a reputation as one of Hollywood's most technically adventurous post-production houses. He joined Bryan and Adam to explore the past, prese…

via Oxide and Friends July 23, 2026

On AI

In 2019, I started watching Andreas Kling's programming videos, many of which were live-coding sessions writing his new operating system Serenity OS. He was always pretty fast at writing code, especially since his IDE, Qt Creator, had knowledge of all his C++ code and could auto-…

via joshua stein July 23, 2026

Hardening Rust Code For Production

We talked about patterns for defensive programming in Rust before, in which implicit invariants that aren’t enforced by the compiler lead to utter misery. But being careful isn’t enough! Even valid code can fail at runtime in ways that are hard to predict and control. That’s what…

via Corrode Rust Consulting July 23, 2026

Generated by openring-rs from my blogroll.