Imposter syndrome in the age of AI

Tue, 21 Apr 2026 00:00:00 -0400

With the rise of large language models (LLM), it’s relatively easy to sound credible about topics that you know little about. Jargon and basic mental models are just a prompt away. In the past, not knowing the right term could trigger imposter syndrome. If anything, now I fear that we may be entering an era where the opposite dynamic exists. Instead of people fearing that they may not know enough, there’s a temptation to think that the response to a clever LLM prompt will yield all the information you need to be considered an “expert”, even if you do not yet know how to discern whether the model is providing you with an answer that effectively balances the nuances of the topic at hand.

The value of muggle mode

Learning requires struggle. For example, imagine the difference between taking a practice test with an answer key available to you. The short-sighted thing to do to get the best test score on the practice test would be to quickly look at the answer key if you’re concerned that you may get a question wrong. However, this will undermine the value of taking a practice test in the first place, since you will be denying yourself the opportunity for a new concept to “click”, which will allow you to effectively handle a future question about a similar concept.

Turning too quickly to AI for the answer is similar to taking a quick peek at the answer key on a practice test when you’re learning something new. At least for now, there’s still a gap between the judgments of AI and human experts.

For me, the most valuable use cases for AI have been to:

Accelerate work that I can easily validate (e.g., writing code, analyzing data, and performing predictable or repetitive tasks).
Ask me questions that can help me think about a problem more rigorously and/or highlight potential ambiguities that could get misunderstood.
Rephrase my writing to strike a particular tone.

Each of these use cases for AI are supplements, not direct outsourcing of my thinking. In many ways, I treat AI in a similar way that I would a person that I’m outsourcing a task to. Even if I paid them to do a task for me, I’d still want to generally understand how and why they were doing things so that I can confirm that they are meeting my goals. In both casual personal and professional settings, increasingly, I’m seeing people just turn to AI for the answer. I’m fully in favor of people using AI to accelerate their work. However, I feel like many people are turning to AI before they understand what they are giving up for their own learning. This is like using advanced power tools before understanding the basics of woodworking.

Before relying too heavily on AI for a task, I suggest trying it first in “muggle mode”. This will help you to better understand where there may be subtle issues that AI might get wrong. In the long run, this will help you to craft an AI based workflow that is more scalable and less prone to mistakes that can propagate in unpredictable ways.

The power move

Understanding your own limitations is a key ingredient to building confidence. This will allow you to intentionally focus on areas for improvement. AI will help you to get good at a specific task, but it may not adapt particularly well when given a slightly different set of circumstances. Overfitting to training data can be a real problem. Be mindful of how this may impact your own learning, especially if you may be suffering from imposter syndrome. This is an instance where going slow at the beginning to make sure you are firmly in control of the fundamentals will lead to faster progress in the medium- to long-term.

Conclusion

I’m curious to hear how others balance their use of AI when they are familiarizing themselves with new disciplines. If you have strategies that you’re willing to share, I’d love to hear from you.

OpenTitan shipping in production

Wed, 04 Mar 2026 00:00:00 -0500

Please find the content for this post on the Google Open Source Blog.

Fabrication begins for production OpenTitan silicon

Thu, 06 Feb 2025 00:00:00 -0500

Please find the content for this post on the Google Open Source Blog.

OpenTitan RTL Freeze

Thu, 15 Jun 2023 00:00:00 -0400

Please find content for this post on the Google Open Source Blog.

Getting started with tmux

Thu, 25 May 2023 00:00:00 -0400

One of the biggest benefits I’ve seen from switching to vim as my primary text editor is that I can use the same text editor whether I ssh into a server, or I use any of my laptops (regardless of operating system). If you’re interested in learning how I use vim, please check out this old post. To keep my workflows as similar as possible, I have also started gravitating to tmux. This post should offer some tips on how to get started with tmux.

Part 1: Core concepts
Part 2: Navigation
Part 3: Configuration
Part 4: Data movement

For this tutorial, I’ll use the following notation:

<C-b> is equivalent to pressing control and b at the same time.
- This is the default prefix which is used to determine whether a command is intended for tmux or the terminal running in the tmux session.
prefix q is equivalent to pressing control and b at the same time, then letting them go and pressing the letter q.

If you’ve used emacs before, you’ll find that a lot of the keybindings bear some resemblance. Let’s get started.

Part 1: Core concepts

Pane: a pseudo terminal
Window: A collection of panes that are shown on screen at the same time. This is similar to what you’d expect to find in a window in an application like iTerm.
- Panes can be arranged however you like within a given window and can be moved between windows.
Session: A collection of windows that are managed by tmux. Sessions can persist in the background if you lose your connection with the server or detach from the session.
- tmux can manage multiple sessions. An arbitrary number of tmux instances can connect to a single session.

Using sessions:

$ tmux new = Creates a new tmux session
$ tmux ls = View current tmux sessions
- prefix s = Navigate between sessions
$ tmux attach -t SESSION_NAME = Attach to an existing tmux session
prefix $ = Rename a session
prefix d = Detach from current session

When you start a new tmux session, a single window with a single pane is created.

This is the end of Part 1 on core concepts.

Now that you have a tmux session, you need to setup up your work environment.

Managing windows:

prefix c = Creates a new window
prefix n = Navigate to the next window
prefix p = Navigate to the previous window
prefix NUM = Navigate to window at index NUM
prefix & = Close current window
prefix , = Rename current window
prefix w = Navigate between windows in active sessions

Managing panes:

prefix % = Creates a new pane by splitting the active pane vertically
prefix " = Creates a new pane by splitting the active pane horizontally
prefix arrow = Move between panes in the direction of the arrow
prefix x = Close active pane
prefix z = Make pane full screen
prefix q = Navigate between panes in active window
prefix ! = Split current pane into its own window

Resizing and moving panes:

prefix <M-arrow> = Resize the current pane
prefix E = Spread out the panes evenly
prefix Space = Select the next default layout
prefix { = Move pane up
prefix } = Move pane down

This is the end of Part 2 on navigation.

Part 3: Configuration

Like with a vimrc, you can add configurations to your tmux.conf. Here are some that you may consider adopting when you’re getting started. To learn more, you can browse the docs.

# tmux.conf
set -g mouse on           # enable mouse scrolling
set -s escape-time 10     # faster command sequences
set -g history-limit 5000 # boost history limit
set -g allow-rename off   # don't rename windows automatically

set -g mode-keys vi       # use vi keybindings for copy mode

# display "tmux.conf loaded!"

This is the end of Part 3 on configuration.

Part 4: Data movement

A key hurdle to me adopting a tmux-based workflow was figuring out how to move data between panes. Now that I know how to use it, I find it much more expressive than using my mouse to select text, and I appreciate having easy access to multiple buffers.

<C-[> = Enter copy mode
q = Exit copy mode
<C-]> = Paste buffer

emacs mode (default)

<C-Space> = Start selection
R = Change to rectangle selection
Use standard emacs movements
<C-w> = Copy selection

vi mode (my preference)

Space = Start selection
v = Change to visual block mode
Use standard vim movements
Enter = Copy selection

Multiple paste buffers

Copied text is placed into a buffer that you can paste later. tmux has the ability to manage multiple buffers. Here are the highlights of how I use them.

<C-=> = View the paste buffers
Enter or p = Paste selected buffer
d = Delete selected buffer

You can read more about copy and paste in tmux here.

This is the end of Part 4 on data movement.

Conclusion

Hope this helps get you oriented with tmux. For a quick refresher about the commands at your disposal, use prefix ?. For more details, I will sometimes browse through $ tmux list-keys to see all of the available keybindings and $ tmux list-commands to see all of the commands that can be used. I realize this is just scratching the surface of how tmux can help improve my workflow. If you have suggestions on things that I should consider trying, please let me know. Happy hacking.

Default to writing a doc

Sun, 18 Dec 2022 00:00:00 -0500

As a product manager, my primary responsibility is to figure out the most valuable use of time for my team and then to ensure that we make forward progress on our goals. In this post, I want to share some of the benefits of developing a habit of writing ideas down by default, even when the contents seem obvious. While my main focus is on how this benefits business owners and product managers, I imagine these observations apply to most job functions. Of course there are also certain situations that are better handled without a written record, but those should be relatively infrequent.

While I know this idea is not novel per se, I thought I would follow my own suggestion of committing these thoughts to writing.

In order for your impact to scale, you need to be able to communicate with more people. Written communication allows you to share ideas asynchronously, which provides you with more reach.
Written documents ensure that you are able to keep everyone up to date on the specifics of your ideas. This will help to minimize the chances of your ideas being recalled incorrectly, which will save you time in the long-run.
- Taking the prerogative to write the first draft of documents will help you frame the conversation and prevent surprises (e.g., scope creep).
- When possible, give concepts / plans a name. This provides useful short-hand for more complicated ideas.
- The process of creating a written document will increase the likelihood of your internalizing, remembering, and acting on its contents. This is important because as a product manager, people will often come to you asking for clarification and they’ll expect you to be able to respond promptly.
Circulating a draft with your ideas offers a mechanism to collect feedback.
- By putting a problem statement and solution in writing, you demonstrate understanding of inputs from your team. This builds trust that you are listening carefully and in your ability to advocate effectively for them.
- If you are having trouble understanding someone’s point of view, you can suggest that they contribute it to your document so that there is a shared source of truth that everyone can refer to. This provides a natural forcing function to clarify definitions, perspectives, and next steps.
- It’s natural to add links to citations or specific data points, which build credibility and would be awkward and inefficient to talk through in conversation.
The presence of a written plan of record inspires confidence. It demonstrates organizational abilities and gives you a tool to hold team members accountable.
- Even if ideas feel obvious, it is helpful to write them down. At the very least, it may help you remember relevant context in the future when you memory starts to fade or you are stretched for time.
- Being able to share a document with people in the future, will help you cut down on the number of meetings you need to have to get people up to speed.
- Having a document also allows you to easily share your work with others who you may not be able to get meetings with either due seniority or scheduling challenges.
Share credit generously. By liberally adding people as coauthors on your documents, you will be gifting them artifacts that they can share with their management chain, customers / partners, or team. And a nice side effect of this is that people will feel good about collaborating with you.

I’ll leave where your documents should live as an exercise for the reader. ;)

Creating custom playing cards

Sat, 27 Mar 2021 00:00:00 -0400

My family enjoys playing bridge. It’s one of the games we enjoy playing most with my grandmother (she still kicks our butts and can count cards better than us). To celebrate her 101st birthday, I thought it would be fun to make a custom deck of cards to share with family and friends since we couldn’t host an in-person celebration this year due to COVID. In this post, I want to share how I went about creating a small run of playing cards that incorporated some fun family jokes and symbology while being of high enough quality that we would still want to play bridge with them.

How to print a small run of playing cards

YouTube is full of wisdom. I was lucky to stumble upon this video created by Rise Magic where they explained their process to create the prototype for their deck of cards. After watching their video, I had a good sense of the defaults I should use when printing the decks with MakePlayingCards.

Here are some cliff notes when selecting the type of cards to have printed so that they’re of a quality that you’d actually want to play with:

Poker size game cards (custom blank)
Use the M31 Linen card stock
Beta finish
You may want to use these Illustrator files that look like the standard USPCC card faces instead of the standard faces provided by MakePlayingCards

Once I had an idea of logistically how to get the cards printed, I needed some help designing three main elements:

The back design
Tuck case
A custom card face for the Queen of Hearts that featured my grandmother’s face

With my level of Illustrator skills, I was able to handle a few other areas of design:

Jokers in the shape of maple leaves since my grandmother was born in Vancouver.
Ace of Spades that incorporates an outline of San Francisco with a Spade cut out of it.
An “Ad” card where my brother and I added a Haiku. In hindsight, I would have left this out, since we only really needed this for the version that we gave to our grandmother.

Finding a designer

I posted a job listing on three sites: Dribbble, UpWork, and Fiverr.

Here’s what I listed:

Title: Custom tuck case for deck of cards

My grandma is turning 101 at the end of the month. She loves playing bridge and I thought that it’d be fun to celebrate her birthday with a custom deck of cards for her and the rest of our family. I’m looking for some help designing a custom tuck case for the deck of cards.

I’m hoping for some help designing the tuck case (and potentially a custom face of the Queen of hearts).

Here’s the rough concept I have in mind:

I would like the tuck case to look similar to the Tally-Ho tuck case

Instead of it saying “A Dougherty” across the top I would like it to say “Chez Lopez”

Where it says “Tally-Ho” I would like it to say “Takako”

Where it says “Linoid Finish” I would like it to say “AKA BUBS”

And then instead of saying “No. 9” I would like it to say “No. 101”

If this is something that you’d be interested in helping me create, please reach out. I’d like to get started ASAP.

Between these three sites, I received 35+ replies within 24 hours. I started conversations with 12 designers whose responses indicated that they had read my post. After a little back and forth, I ultimately talked on the phone with 4 designers and then decided to work with Alli Elster, whom I found on Dribbble. Part of what excited me about working with Alli was her past experience with designs involving playing cards.

Given that this brief was pretty concrete, I appreciated that Alli was willing to offer a fixed price quote. Alli did great work and the cards turned out exactly as I had hoped! I’ve started working on another project with her. If you are looking for a talented, personable designer, I highly recommend working with Alli!

Potential gotchas when uploading images

When I uploaded images to MakePlayingCards, I wasn’t sure what resolution would be necessary for the images not to be fuzzy because the previews were pretty small. If you have the option, export the images you want to use at a much higher resolution than you think you need to ensure that everything comes out crisply when it’s printed. I exported images that are 4x larger than required.

The other area where I made a mistake was in uploading the box design. You may want to print out the pdf template with your design on it and try folding it before you finalize your order. I found that I should have rotated one of the face designs 180º from what I had added initially.

Conclusion

I found this process pretty fun. And the cards have gone over well with the family. I hope this blog post can help speed up your learning process if you decide to try something similar.

Using WhatsApp for political organizing

Thu, 24 Dec 2020 00:00:00 -0500

A friend was recently sending messages to voters in Georgia before the upcoming runoff elections using WhatsApp and he had an experience that reminded me of the power Facebook holds over our ability to effectively and freely communicate. In this case, the support team’s resolution seemed appropriate, but nevertheless unsettling.

To be clear, this post is not meant to be about Facebook and its policies; it’s a broader reflection on our dependence on private companies to exercise our democratic rights. This same scenario could have easily occurred using any messaging service, not just WhatsApp.

Background

For the sake of this story, we’ll call my friend Paul. Here’s some background information:

Paul has a WhatsApp account, but had not used it in a long time (3+ months).
Most of Paul’s WhatsApp messages are in English, but there are also a significant number of messages with people written in Spanish from when Paul lived in Latin America.
A political organizer had reached out to Paul about texting registered voters in Spanish to ensure that they had a plan to vote in the upcoming election.
Paul installed the desktop WhatsApp application for Mac OS for the first time.
Paul sent ~100 messages written in Spanish using the WhatsApp desktop application to registered voters that followed a similar template, but that were personalized with the voter’s name. These messages were all sent over the course of ~1 hour.
Paul received a message from WhatsApp that his account had been banned for violating the Terms of Service.

Your phone number +1 (XYZ) XYZ-WXYZ is banned from using WhatsApp. Please contact customer support for assistance.

After providing a pdf of his latest phone bill to prove ownership of his phone number, Paul was able to reactivate his WhatsApp account.

Reflection on the situation and the nature of spam

I imagine that Paul’s relatively sudden change in behavior triggered an automated system that flagged his account for spam activity. This was likely due to the dramatic increase in messages being sent, message similarity, messages being sent from the desktop application for the first time, or a number of recipients flagging the messages as unwanted.

From WhatsApp’s point of view, it’s hard to distinguish between unwanted messages being sent en masse and unwanted messages being sent on a relatively small scale to strangers for political outreach. Given that both types of messages are between parties that have never communicated together before and where the recipients may not want to be receiving the messages in the first place, there’s no obvious heuristic to tell the difference between these use cases.

Resolution paths

In this situation, I think WhatsApp could have sent Paul an automated warning to say that he could not longer send messages to accounts who had not responded to him for 72 hours while they assessed whether or not he was a real person. Or, the automated message could share that Paul’s account had been flagged for suspcious activity and would be shut off if the activity continued. The automated messaged would have had the desired effect of limiting spam while continuing to allow Paul to access his account.

Instead of taking this warning approach, Paul received a notification that his account had been banned. Not only could he no longer send messages, but he also could not look at previous messages that he had sent. Understandably, some of the exchanges he’d had with his host family in Latin America had sentimental value. So, the prospect of having his account banned in trying to help a political cause he cared about seemed particularly stark.

Chilling effect

While the net effect of WhatsApp’s current process for resolving this type of situation and WhatsApp sending a warning that service will shut off may be the same, the way in which the issue has been communicated to Paul made him worry that he had bricked his phone number.

In other words, he could continue to use his phone, but if he ever wanted to use WhatsApp again, he’d need to get a new phone number. This would be a huge hassle because it would require reaching out to each of Paul’s contacts and figuring out all of the services that use his phone number for multifactor authentication, so that he wouldn’t inadvertently lock himself out of other services.

Paul was also worried about how he’d handle future travel in Latin America. Having WhatsApp is key for communication, so before the issue was resolved, Paul started thinking about whether he’d need to get a “disposable” phone number the next time he went on a trip to communicate with friends and AirBnB hosts.

The risk of having to resolve this kind of hassle was not what Paul bargained for when he signed up to help the political organizer in Georgia. The result of this experience is that Paul does not want to use his personal WhatsApp again when helping to advance political causes he believes in.

Technology and political campaigns

Right now, poltical campaigns routinely ask volunteers to use their own technology when reaching out to potential supporters. For phone calls, they typically use an online dialer service that does not require the volunteer to use their personal phone number. And for many text message campaigns, the same is true.

But, there’s another significant portion of outreach where volunteers and staff members do use their personal phone numbers. Paul’s experience makes me wonder whether campaign related outreach should go through registered phone numbers (similar to short codes) that would identify themselves as associated with political campaigns so that recipients can decide to opt out of if they’re not interested it receiving campaign calls and texts. This seems like a system that would be better for voters not interested in being bombarded before election day and for volunteers eager to engage in the political system without the risk of unintended hassles related to their personal phone subscriptions.

Conclusion

This was a scenario where both Paul and WhatsApp were well-intentioned, but has left Paul less enthusiastic about volunteering for political causes he believes in. In the future, I hope political campaigns will work with service providers to make it easier for volunteers to engage without this risk. I also hope that private companies that facilitate communication will give users warnings before making them feel like they’ve been banned for life.

Using Rails templates

Wed, 21 Oct 2020 00:00:00 -0400

One of the hardest parts of starting a new project (of any kind) is the initial setup. Code generators have helped me to overcome this mental friction when working with software. In this tutorial, I’ll share how I’ve constructed my Rails template to jumpstart my development process and quickly start digging into the features that make a particular project unique instead of getting bogged down writing boilerplate code.

Rule of thumb: if I find myself doing the same thing for the third time, I automate it.

If you haven’t used Rails templates before, I highly recommend reading the official guide. I wish someone had told me to read this when I was first learning Rails.

Structuring my template file

When setting up a new Rails project I have a checklist of things I need to do regardless of what makes the project unique:

Installing dependencies
Setting up basic layouts and adding font awesome
Adding js to power disappearing flash messages and hamburger menus
Configuring user authentication
Adding user authorization / permissioning
Adding pagination
Setting up transactional email
Setting up workers for background jobs
Configuring Vue.js with webpacker
Updating the scaffold generator to match my layout

Fortunately, a Rails template is just a plain ruby DSL. The one I’ll show you uses fileutils and shellwords, so it can be loaded locally or from the web, which is a trick I learned from mattbrictson/rails-template on Github. In effect, the template will clone its own git repo into a temp directory if it’s being loaded from the web, so the file structure of the repository can be used by Thor actions like copy_file.

def add_template_repository_to_source_path
  if __FILE__ =~ %r{\Ahttps?://}
    git_repo = "<<LINK TO YOUR TEMPLATE REPO>>"

    require "tmpdir"
    source_paths.unshift(tempdir = Dir.mktmpdir("jumpstart-"))
    at_exit { FileUtils.remove_entry(tempdir) }
    git clone: [
      "--quiet",
      git_repo,
      tempdir
    ].map(&:shellescape).join(" ")

    if (branch = __FILE__[%r{<<REPO_NAME>>/(.+)/template.rb}, 1])
      Dir.chdir(tempdir) { git checkout: branch }
    end
  else
    source_paths.unshift(File.dirname(__FILE__))
  end
end

Basic file structure

If you’ve worked with Rails, this file structure should look familiar. By closely mirroring the standard Rails file structure, it’s easy to keep files up to date.

.
├── Procfile # To make it easy to deploy to Heroku
├── README.md
├── app
│   ├── assets (*)
│   ├── helpers (*)
│   ├── javascript (*)
│   ├── models (*)
│   ├── policies (*)
│   └── views (*)
├── config
│   ├── cable.yml
│   ├── initializers (*)
│   ├── locales (*)
│   └── sidekiq.yml
├── env
├── lib
│   └── templates (*)
├── ruby-version
├── template.rb # Where the main logic lives
└── test
    ├── controllers (*)
    ├── fixtures (*)
    └── policies (*)

Subdirectories in app, config, lib, and test will be copied directly into the new Rails project. In this tutorial, I’ll go through some examples to give you an idea of how to do this, but since these are a matter of preference, you’ll probably be best served writing these yourself.

Installing dependencies

Here are some methods that I’ve written in template.rb to install common dependencies for my Rails projects.

def add_root_directory_files
  copy_file "env", ".env" 
  copy_file "Procfile" 

  template "ruby-version.tt", ".ruby-version", force: true
  append_to_file ".gitignore", "\n.env*\n!.env.example"
end

def add_dependencies
  gem 'devise'
  gem 'font-awesome-sass'
  gem 'friendly_id'
  gem 'kaminari'
  gem 'pundit'
  gem 'sidekiq'

  run "yarn add bulma"
end

I’ve found that I prefer the following included in my local .env file. I imagine you’ll find that you have preferences you’ll want included as well.

# env
RACK_ENV=development
RUBYOPT='-W:no-deprecated -W:no-experimental'

Once these files are in place, the gems need to be installed and the remaining commands will be run inside the following block:

after_bundle do
  # add code generators described below here

  rails_command "db:create"
  rails_command "db:migrate"
  git :init
  git add: "."
  git commit: %Q{ -m 'Initial commit' }
end

Setting up basic layouts and font awesome

For every Rails project that I work on, I find that I start by adding these files.

def copy_templates
  run "rm app/assets/stylesheets/application.css"

  directory "app", force: true
  directory "config", force: true
  directory "lib", force: true
  directory "test", force: true

  # These templates incorporate the name of the project
  template "app/helpers/shared_helper.rb.tt"
  template "app/views/layouts/_header.html.erb.tt"
  template "app/views/layouts/_social_headers.html.erb.tt"
  template "app/views/users/mailer/confirmation_instructions.html.erb.tt"
end

Then, I always add a couple static pages: one to serve as a landing page and one to explain what the web application does.

def create_pages_controller
  generate "controller pages home about"
  route "get 'home', to: 'pages#home'"
  route "get 'about', to: 'pages#about'"

  gsub_file "config/routes.rb", "get 'pages/home'\n", ""
  gsub_file "config/routes.rb", "get 'pages/about'\n", ""
end

Adding js to power disappearing flash messages and hamburger menus

This is included in app/javascript/packs/ directory that was copied over in copy_templates described above.

Configuring user authentication

With Devise already installed above, this code ensures that it’s been configured properly. I’ve found that I often customize the controller logic and want the ability to designate certain users as admins. Note: The production mail url options still need to be configured once a domain has been procured.

def create_user_model_and_controllers
  # Install Devise
  generate "devise:install"

  # Configure Devise
  environment "config.action_mailer.default_url_options =" +
    " { host: 'localhost', port: 5000 }", env: 'development'
  environment "#config.action_mailer.default_url_options =" + 
    " { host: 'localhost' }", env: 'production'
  route "root to: 'pages#home'"

  # Create Devise User
  generate :devise, "User", "admin:integer"

  # Set admin default to false
  in_root do
    migration = Dir.glob("db/migrate/*").max_by{ |f| File.mtime(f) }
    gsub_file migration, /:admin/, ":admin, default: 0"
    gsub_file migration, /\# t/, "t" # uncommenting columns
    gsub_file migration, /\# a/, "a" # uncommenting indices
  end

  # Using explicit controllers
  generate "devise:controllers", "users"

  gsub_file "config/routes.rb", "devise_for :users",
  %Q(devise_for :users, controllers: {
    confirmations: 'users/confirmations',
    invitations: 'users/invitations',
    # omniauth_callbacks: 'users/omniauth_callbacks',
    passwords: 'users/passwords',
    registrations: 'users/registrations',
    sessions: 'users/sessions',
    unlocks: 'users/unlocks'
  })
end

Adding user authorization

This logic configures Pundit to check user permissions and adds helper methods to make writing tests easier.

def install_pundit
  insert_into_file "app/controllers/application_controller.rb",
    "\n  include Pundit",
    after: "class ApplicationController < ActionController::Base"
  insert_into_file "app/controllers/application_controller.rb",
    "\n  protect_from_forgery",
    after: "include Pundit"

  generate "pundit:install"

  # Add convenience methods to the test_helper

  convenience_class = %q{
class PolicyTest < ActiveSupport::TestCase
  def permit(current_user, record, action)
    self.class.to_s.gsub(/Test/, '').constantize
      .new(current_user, record).public_send("#{action.to_s}?")
  end

  def forbid(current_user, record, action)
    !permit(current_user, record, action)
  end
end}

  append_to_file "test/test_helper.rb", convenience_class
end

Adding pagination

For my installation, all of the customization is present in app/views/kaminari/.

Setting up transactional email

To support Sendgrid, I add the following so that I can easily use the Heroku Add-on:

# config/initializers/setup_mail.rb
ActionMailer::Base.smtp_settings = {
  :user_name => ENV['SENDGRID_USERNAME'],
  :password => ENV['SENDGRID_PASSWORD'],
  :domain => 'localhost',
  :address => 'smtp.sendgrid.net',
  :port => 587,
  :authentication => :plain,
  :enable_starttls_auto => true
}

Setting up workers for background jobs

This will configure Sidekiq with ActiveJob and mount the dashboard in the routes file.

def add_sidekiq
  environment "config.active_job.queue_adapter = :sidekiq"

  insert_into_file "config/routes.rb",
    "require 'sidekiq/web'\n\n",
    before: "Rails.application.routes.draw do"

  insert_into_file "config/routes.rb",
    "  authenticate :user, lambda { |u| u.admin? } do\n" +
    "    mount Sidekiq::Web => '/sidekiq'\n  end\n",
    after: "https://guides.rubyonrails.org/routing.html\n"
end

def update_test_helper
  insert_into_file "test/test_helper.rb", "require 'minitest/autorun'\n" +
    "require 'sidekiq/testing'\n\n",
    before: "class ActiveSupport::TestCase"
end

Configuring Vue.js with webpacker

This adds Vue.js to webpacker and supports it working in conjunction with Turbolinks. You can learn more about the split chunks configuration here.

def add_vuejs
  rails_command 'webpacker:install:vue'

  # Remove base files
  run "rm app/javascript/app.vue"
  run "rm app/javascript/packs/application.js"
  run "rm app/javascript/packs/hello_vue.js"

  run "yarn add vue vue-loader vue-turbolinks"

  insert_into_file "config/webpack/environment.js",
    "const WebpackAssetsManifest = require('webpack-assets-manifest')\n",
    before: "module.exports = environment"
  insert_into_file "config/webpack/environment.js",
    "environment.splitChunks()\n",
    before: "module.exports = environment"
end

To make Vue.js play nice with Turbolinks, I add the following:

// app/javascripts/packs/vue_container.js

// import axios from 'axios'
import Vue from 'vue/dist/vue.esm'
import TurbolinksAdapter from 'vue-turbolinks'

Vue.use(TurbolinksAdapter)
Vue.config.productionTip = false
// Vue.prototype.$http = axios

document.addEventListener('turbolinks:load', () => {
  // const csrfTokenEl = document.querySelector('meta[name="csrf-token"]')
  // axios.defaults.headers.common = {
  //   "Accept": "application/json, text/plain, */*",
  //   "X-CSRF-Token": csrfTokenEl.getAttribute('content'),
  //   "X-Requested-With": "XMLHttpRequest"
  // }

  var container = document.querySelector('[vue-enabled]')
  if (container != null) {
    const app = new Vue({
    }).$mount(container)
  }
})

Updating the scaffold generator

Add the relevant template files in lib/templates/erb/scaffold/. In my case, I’ve written some files to make it so that the generated forms make use of Bulma CSS classes.

Conclusion

This isn’t a lot of code. But, it makes it much easier to start building a prototype that may still be a fragile idea in my head. I think this type of setup without automation used to take me a couple hours. Now it’s just a few minutes. I hope this will help you feel more inclined to experiment and spend more time building. Happy hacking.

When does data become identifiable?

Wed, 05 Aug 2020 00:00:00 -0400

Issues regarding data privacy have become increasingly important as tech companies continue to develop new ways of monetizing the information they have gathered about their users. In response, many new privacy regulations are being instituted around the world, from CCPA in California to GDPR in Europe. At the heart of these laws is what constitutes personally identifiable information.

tl;dr The legal definition of personal information is vague and difficult to apply.

CCPA defines “personal information” as “information that identifies, relates to, describes, is capable of being associated with, or could reasonably be linked, directly or indirectly, with a particular consumer or household.” And, GDPR defines “personal data” as “any information relating to an identified or identifiable natural person (‘data subject’); an identifiable natural person is one who can be identified, directly or indirectly, in particular by reference to an identifier such as a name, an identification number, location data, an online identifier or to one or more factors specific to the physical, physiological, genetic, mental, economic, cultural or social identity of that natural person.”

Determining identifiability in some cases is obvious. For example, if a user provides their social security number, because each number is associated with a specific individual, then it’s pretty clear that that’s personal information. On the other hand, if a user fills out a multiple choice survey that is submitted anonymously without any attached metadata, then it’s reasonably safe to assume that it’s not personally identifiable (presuming there are a sufficient number of survey-takers). But, most cases fall somewhere in between these two extremes.

In this post, I’ll highlight a distinction that seems to be missing between these two extremes. The current definitions have an inadequate level of specificity regarding personal information. This means that many types of data may not receive necessary protections (leaving some data vulnerable) and some may receive unnecessary protection (potentially impeding beneficial innovation). All of this is to say that different levels of identifiability aren’t black and white. We need to shift our mindset to evaluate identifiability on a spectrum.

Note: The harms of data misuse or lack of protection are well documented. This post is focused on exploring how to answer the question of whether given data is identifiable.

Inferred data

Data can be used to infer information that you’d reasonably expect to be kept private, including sensitive data (e.g., health status and credit-worthiness) and information about race, sex, religion etc … (which are protected classes in the American legal system). This is important because sensitive data, “suspect class” data, or other seemingly-benign data can be used in discriminatory ways. Here are some examples.

In other words, data can implicitly be used to identify characteristics about a user that they may not have intended or wanted to share. In isolation a single data point may not be useful in identifying someone, but when taken together, a constellation of data points can create a recognizable pattern. This should not be surprising anymore as we have all become accustomed to ad targeting being eerily in sync with our interests. Read more here.

Example of the challenge of identifiability: voice data

With the rise of personal assistants like Siri, Alexa, Google Assistant, Portal etc … we are handing over more voice data than ever before. Should a short voice recording (that is unlabeled and unmorphed) be considered personally identifiable? If this kind of short audio recording were shared with the broader organization collecting the data (e.g., Apple, Amazon, Google, Facebook, etc …, or a hacker), it would be hard to match this audio recording to a specific person. However, if I heard a short recording of my own voice, I would likely be able to identify it as my own.

On the other hand, a longer audio clip where users provide context clues that can be used to identify them would be a different story. It seems clear that the broader organization collecting the data (e.g., Apple, Amazon, Google, Facebook, etc …, or a hacker) would be able to easily identify the user who created the recording with minimal effort.

It seems inappropriate for there to be a one size fits all approach to these two voice recordings. Both voice files can be personally identified, given the right contextual information and technological capabilities. The challenge is that big tech companies, non-tech companies, and other potential adversaries have different capabilities to identify people based on their voices. Because of this, regulations should strive to incorporate nuance between these different types of identifiability.

Proposed distinction: P vs NP-style data

In describing these different types of information, it reminded me of the distinction between what computer scientists refer to as P and NP problems.

In layman’s terms, the solution to a P problem can be found in polynomial time. In other words, given a set of inputs, I can use a simple algorithm to find a solution. In the case of personally identifiable data, that would mean, if I am given a data sample, I can run a reasonably straightforward model to determine who the data belongs to. In its simplest form, this would mean looking at the unique identifier associated with it. In a slightly more complicated example, this may mean computing a faceprint from an image and then comparing that to a database of faceprints to identify the person in the photo. There may be some margin for error, but this process should never devolve into a brute force exercise.

On the other hand, with an NP problem, I can identify whether a proposed solution is valid in polynomial time. The key distinction here is that for an NP problem, I cannot necessarily find a solution in polynomial time, but I can verify that a solution is valid in polynomial time. For example, I can easily tell when a jigsaw puzzle has been solved correctly, but I cannot easily solve a jigsaw puzzle by simply looking at the pieces. Alternatively, presume that a model can detect that the same person is speaking in two recordings. Then, you can quickly identify that there is a match. But, if you only have one recording it’s much harder to determine who is speaking in the recording.

While both types of information may be personally identifiable, I would argue that in my analogy, personally identifiable information in the “P-style problem” space should be granted a heightened level of privacy protection. In other words, whether under CCPA or GDPR, there should be an expectation for consumers that this type of personally identifiable information be deleted upon request. On the other hand, if data is “NP personally identifiable” I think that companies should be granted more slack if they lack the necessary contextual information and technological capability to make the match.

When thinking about the risk profile for these different types of information, it seems clear that “P-style personally identifiable information” can be easily linked to a specific person even with limited sophistication. This is particularly worrisome since this type of data may be divulged as part of data breach to the open internet. This means that an individual with a vendetta could weaponize this data relatively anonymously, meaning that those who suffered harm would be less likely to find a remedy through the justice system for this harm.

On the other hand, for “NP-style personally identifiable information” to be used, an organization would need to be able to contextualize that data. For a given data set, due to practicalities, only a limited number of companies and state actors have these capabilities. Oftentimes, these organizations will be large companies that have a large corpus of data; but, there may also be small companies that have the necessary data for contextualization (e.g., a data set about a company’s employees).

The current critiques of big tech companies regarding data protection are warranted, but identifiability isn’t only contingent on having large data sets. As discussed earlier, an organization only needs to have the right contextual information to identify the data.

Conclusion

Currently, personally identifiable information is generally treated as a single classification. How to treat P-style data within this framework is clear; the question is how to approach NP-style data. With greater nuance, regulations can be more impactful and enforceable, giving individuals more control of their data.

In the absence of clear guidance, a likely default is for companies to adopt the least restrictive approach since they have a clear incentive to minimize risk by labeling as little data as possible as “personally identifiable” and therefore avoiding regulatory requirements.

I’d love to hear your thoughts on whether this distinction would be helpful in crafting your internal data practices.

Imposter syndrome in the age of AI

The value of muggle mode

The power move

Conclusion

OpenTitan shipping in production

Fabrication begins for production OpenTitan silicon

OpenTitan RTL Freeze

Getting started with tmux

Part 1: Core concepts

Part 2: Navigation

Part 3: Configuration

Part 4: Data movement

Conclusion

Default to writing a doc

Creating custom playing cards

How to print a small run of playing cards

Finding a designer

Potential gotchas when uploading images

Conclusion

Using WhatsApp for political organizing

Background

Reflection on the situation and the nature of spam

Resolution paths

Chilling effect

Technology and political campaigns

Conclusion

Using Rails templates

Structuring my template file

Basic file structure

Installing dependencies

Setting up basic layouts and font awesome

Adding js to power disappearing flash messages and hamburger menus

Configuring user authentication

Adding user authorization

Adding pagination

Setting up transactional email

Setting up workers for background jobs

Configuring Vue.js with webpacker

Updating the scaffold generator

Conclusion

When does data become identifiable?

Inferred data

Example of the challenge of identifiability: voice data

Proposed distinction: P vs NP-style data

Conclusion